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/external_transforms.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.ExternalConfigurationPayload)
pub struct ExternalConfigurationPayload {
    // message fields
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.ExternalConfigurationPayload.schema)
    pub schema: ::protobuf::MessageField<super::schema::Schema>,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.ExternalConfigurationPayload.payload)
    pub payload: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.ExternalConfigurationPayload.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

impl ExternalConfigurationPayload {
    pub fn new() -> ExternalConfigurationPayload {
        ::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::<_, super::schema::Schema>(
            "schema",
            |m: &ExternalConfigurationPayload| { &m.schema },
            |m: &mut ExternalConfigurationPayload| { &mut m.schema },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "payload",
            |m: &ExternalConfigurationPayload| { &m.payload },
            |m: &mut ExternalConfigurationPayload| { &mut m.payload },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<ExternalConfigurationPayload>(
            "ExternalConfigurationPayload",
            fields,
            oneofs,
        )
    }
}

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

    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)?;
                },
                18 => {
                    self.payload = 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 Some(v) = self.schema.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if !self.payload.is_empty() {
            my_size += ::protobuf::rt::bytes_size(2, &self.payload);
        }
        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)?;
        }
        if !self.payload.is_empty() {
            os.write_bytes(2, &self.payload)?;
        }
        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() -> ExternalConfigurationPayload {
        ExternalConfigurationPayload::new()
    }

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

    fn default_instance() -> &'static ExternalConfigurationPayload {
        static instance: ExternalConfigurationPayload = ExternalConfigurationPayload {
            schema: ::protobuf::MessageField::none(),
            payload: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for ExternalConfigurationPayload {
    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("ExternalConfigurationPayload").unwrap()).clone()
    }
}

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

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

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

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

impl ExpansionMethods {
    pub fn new() -> ExpansionMethods {
        ::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::<ExpansionMethods>(
            "ExpansionMethods",
            fields,
            oneofs,
        )
    }
}

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

    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() -> ExpansionMethods {
        ExpansionMethods::new()
    }

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

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

impl ::protobuf::MessageFull for ExpansionMethods {
    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("ExpansionMethods").unwrap()).clone()
    }
}

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

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

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

    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::JAVA_CLASS_LOOKUP),
                _ => ::std::option::Option::None
            }
        }

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

    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("ExpansionMethods.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::JAVA_CLASS_LOOKUP
        }
    }

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

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.JavaClassLookupPayload)
pub struct JavaClassLookupPayload {
    // message fields
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.JavaClassLookupPayload.class_name)
    pub class_name: ::std::string::String,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.JavaClassLookupPayload.constructor_method)
    pub constructor_method: ::std::string::String,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.JavaClassLookupPayload.constructor_schema)
    pub constructor_schema: ::protobuf::MessageField<super::schema::Schema>,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.JavaClassLookupPayload.constructor_payload)
    pub constructor_payload: ::std::vec::Vec<u8>,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.JavaClassLookupPayload.builder_methods)
    pub builder_methods: ::std::vec::Vec<BuilderMethod>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.JavaClassLookupPayload.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

impl JavaClassLookupPayload {
    pub fn new() -> JavaClassLookupPayload {
        ::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::<_, _>(
            "class_name",
            |m: &JavaClassLookupPayload| { &m.class_name },
            |m: &mut JavaClassLookupPayload| { &mut m.class_name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "constructor_method",
            |m: &JavaClassLookupPayload| { &m.constructor_method },
            |m: &mut JavaClassLookupPayload| { &mut m.constructor_method },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::schema::Schema>(
            "constructor_schema",
            |m: &JavaClassLookupPayload| { &m.constructor_schema },
            |m: &mut JavaClassLookupPayload| { &mut m.constructor_schema },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "constructor_payload",
            |m: &JavaClassLookupPayload| { &m.constructor_payload },
            |m: &mut JavaClassLookupPayload| { &mut m.constructor_payload },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_vec_simpler_accessor::<_, _>(
            "builder_methods",
            |m: &JavaClassLookupPayload| { &m.builder_methods },
            |m: &mut JavaClassLookupPayload| { &mut m.builder_methods },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<JavaClassLookupPayload>(
            "JavaClassLookupPayload",
            fields,
            oneofs,
        )
    }
}

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

    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.class_name = is.read_string()?;
                },
                18 => {
                    self.constructor_method = is.read_string()?;
                },
                26 => {
                    ::protobuf::rt::read_singular_message_into_field(is, &mut self.constructor_schema)?;
                },
                34 => {
                    self.constructor_payload = is.read_bytes()?;
                },
                42 => {
                    self.builder_methods.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.class_name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.class_name);
        }
        if !self.constructor_method.is_empty() {
            my_size += ::protobuf::rt::string_size(2, &self.constructor_method);
        }
        if let Some(v) = self.constructor_schema.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if !self.constructor_payload.is_empty() {
            my_size += ::protobuf::rt::bytes_size(4, &self.constructor_payload);
        }
        for value in &self.builder_methods {
            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.class_name.is_empty() {
            os.write_string(1, &self.class_name)?;
        }
        if !self.constructor_method.is_empty() {
            os.write_string(2, &self.constructor_method)?;
        }
        if let Some(v) = self.constructor_schema.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(3, v, os)?;
        }
        if !self.constructor_payload.is_empty() {
            os.write_bytes(4, &self.constructor_payload)?;
        }
        for v in &self.builder_methods {
            ::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() -> JavaClassLookupPayload {
        JavaClassLookupPayload::new()
    }

    fn clear(&mut self) {
        self.class_name.clear();
        self.constructor_method.clear();
        self.constructor_schema.clear();
        self.constructor_payload.clear();
        self.builder_methods.clear();
        self.special_fields.clear();
    }

    fn default_instance() -> &'static JavaClassLookupPayload {
        static instance: JavaClassLookupPayload = JavaClassLookupPayload {
            class_name: ::std::string::String::new(),
            constructor_method: ::std::string::String::new(),
            constructor_schema: ::protobuf::MessageField::none(),
            constructor_payload: ::std::vec::Vec::new(),
            builder_methods: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for JavaClassLookupPayload {
    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("JavaClassLookupPayload").unwrap()).clone()
    }
}

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

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

#[derive(PartialEq,Clone,Default,Debug)]
// @@protoc_insertion_point(message:org.apache.beam.model.pipeline.v1.BuilderMethod)
pub struct BuilderMethod {
    // message fields
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.BuilderMethod.name)
    pub name: ::std::string::String,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.BuilderMethod.schema)
    pub schema: ::protobuf::MessageField<super::schema::Schema>,
    // @@protoc_insertion_point(field:org.apache.beam.model.pipeline.v1.BuilderMethod.payload)
    pub payload: ::std::vec::Vec<u8>,
    // special fields
    // @@protoc_insertion_point(special_field:org.apache.beam.model.pipeline.v1.BuilderMethod.special_fields)
    pub special_fields: ::protobuf::SpecialFields,
}

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

impl BuilderMethod {
    pub fn new() -> BuilderMethod {
        ::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: &BuilderMethod| { &m.name },
            |m: &mut BuilderMethod| { &mut m.name },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_message_field_accessor::<_, super::schema::Schema>(
            "schema",
            |m: &BuilderMethod| { &m.schema },
            |m: &mut BuilderMethod| { &mut m.schema },
        ));
        fields.push(::protobuf::reflect::rt::v2::make_simpler_field_accessor::<_, _>(
            "payload",
            |m: &BuilderMethod| { &m.payload },
            |m: &mut BuilderMethod| { &mut m.payload },
        ));
        ::protobuf::reflect::GeneratedMessageDescriptorData::new_2::<BuilderMethod>(
            "BuilderMethod",
            fields,
            oneofs,
        )
    }
}

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

    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.schema)?;
                },
                26 => {
                    self.payload = 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 !self.name.is_empty() {
            my_size += ::protobuf::rt::string_size(1, &self.name);
        }
        if let Some(v) = self.schema.as_ref() {
            let len = v.compute_size();
            my_size += 1 + ::protobuf::rt::compute_raw_varint64_size(len) + len;
        }
        if !self.payload.is_empty() {
            my_size += ::protobuf::rt::bytes_size(3, &self.payload);
        }
        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.schema.as_ref() {
            ::protobuf::rt::write_message_field_with_cached_size(2, v, os)?;
        }
        if !self.payload.is_empty() {
            os.write_bytes(3, &self.payload)?;
        }
        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() -> BuilderMethod {
        BuilderMethod::new()
    }

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

    fn default_instance() -> &'static BuilderMethod {
        static instance: BuilderMethod = BuilderMethod {
            name: ::std::string::String::new(),
            schema: ::protobuf::MessageField::none(),
            payload: ::std::vec::Vec::new(),
            special_fields: ::protobuf::SpecialFields::new(),
        };
        &instance
    }
}

impl ::protobuf::MessageFull for BuilderMethod {
    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("BuilderMethod").unwrap()).clone()
    }
}

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

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

static file_descriptor_proto_data: &'static [u8] = b"\
    \n;org/apache/beam/model/pipeline/v1/external_transforms.proto\x12!org.a\
    pache.beam.model.pipeline.v1\x1a.org/apache/beam/model/pipeline/v1/schem\
    a.proto\x1a7org/apache/beam/model/pipeline/v1/beam_runner_api.proto\"{\n\
    \x1cExternalConfigurationPayload\x12A\n\x06schema\x18\x01\x20\x01(\x0b2)\
    .org.apache.beam.model.pipeline.v1.SchemaR\x06schema\x12\x18\n\x07payloa\
    d\x18\x02\x20\x01(\x0cR\x07payload\"d\n\x10ExpansionMethods\"P\n\x04Enum\
    \x12H\n\x11JAVA_CLASS_LOOKUP\x10\0\x1a1\xa2\xb4\xfa\xc2\x05+beam:expansi\
    on:payload:java_class_lookup:v1\"\xcc\x02\n\x16JavaClassLookupPayload\
    \x12\x1d\n\nclass_name\x18\x01\x20\x01(\tR\tclassName\x12-\n\x12construc\
    tor_method\x18\x02\x20\x01(\tR\x11constructorMethod\x12X\n\x12constructo\
    r_schema\x18\x03\x20\x01(\x0b2).org.apache.beam.model.pipeline.v1.Schema\
    R\x11constructorSchema\x12/\n\x13constructor_payload\x18\x04\x20\x01(\
    \x0cR\x12constructorPayload\x12Y\n\x0fbuilder_methods\x18\x05\x20\x03(\
    \x0b20.org.apache.beam.model.pipeline.v1.BuilderMethodR\x0ebuilderMethod\
    s\"\x80\x01\n\rBuilderMethod\x12\x12\n\x04name\x18\x01\x20\x01(\tR\x04na\
    me\x12A\n\x06schema\x18\x02\x20\x01(\x0b2).org.apache.beam.model.pipelin\
    e.v1.SchemaR\x06schema\x12\x18\n\x07payload\x18\x03\x20\x01(\x0cR\x07pay\
    loadB\x81\x01\n!org.apache.beam.model.pipeline.v1B\x12ExternalTransforms\
    ZHgithub.com/apache/beam/sdks/v2/go/pkg/beam/model/pipeline_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(2);
            deps.push(super::schema::file_descriptor().clone());
            deps.push(super::beam_runner_api::file_descriptor().clone());
            let mut messages = ::std::vec::Vec::with_capacity(4);
            messages.push(ExternalConfigurationPayload::generated_message_descriptor_data());
            messages.push(ExpansionMethods::generated_message_descriptor_data());
            messages.push(JavaClassLookupPayload::generated_message_descriptor_data());
            messages.push(BuilderMethod::generated_message_descriptor_data());
            let mut enums = ::std::vec::Vec::with_capacity(1);
            enums.push(expansion_methods::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)
    })
}