buffa_descriptor/generated/

google.protobuf.descriptor.rs

// @generated by buffa-codegen. DO NOT EDIT.
// source: google/protobuf/descriptor.proto

/// The full set of known editions.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
#[repr(i32)]
pub enum Edition {
    /// A placeholder for an unknown edition value.
    EDITION_UNKNOWN = 0i32,
    /// A placeholder edition for specifying default behaviors *before* a feature
    /// was first introduced.  This is effectively an "infinite past".
    EDITION_LEGACY = 900i32,
    /// Legacy syntax "editions".  These pre-date editions, but behave much like
    /// distinct editions.  These can't be used to specify the edition of proto
    /// files, but feature definitions must supply proto2/proto3 defaults for
    /// backwards compatibility.
    EDITION_PROTO2 = 998i32,
    EDITION_PROTO3 = 999i32,
    /// Editions that have been released.  The specific values are arbitrary and
    /// should not be depended on, but they will always be time-ordered for easy
    /// comparison.
    EDITION_2023 = 1000i32,
    EDITION_2024 = 1001i32,
    /// A placeholder edition for developing and testing unscheduled features.
    EDITION_UNSTABLE = 9999i32,
    /// Placeholder editions for testing feature resolution.  These should not be
    /// used or relied on outside of tests.
    EDITION_1_TEST_ONLY = 1i32,
    EDITION_2_TEST_ONLY = 2i32,
    EDITION_99997_TEST_ONLY = 99997i32,
    EDITION_99998_TEST_ONLY = 99998i32,
    EDITION_99999_TEST_ONLY = 99999i32,
    /// Placeholder for specifying unbounded edition support.  This should only
    /// ever be used by plugins that can expect to never require any changes to
    /// support a new edition.
    EDITION_MAX = 2147483647i32,
}
impl Edition {
    ///Idiomatic alias for [`Self::EDITION_UNKNOWN`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const EditionUnknown: Self = Self::EDITION_UNKNOWN;
    ///Idiomatic alias for [`Self::EDITION_LEGACY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const EditionLegacy: Self = Self::EDITION_LEGACY;
    ///Idiomatic alias for [`Self::EDITION_PROTO2`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const EditionProto2: Self = Self::EDITION_PROTO2;
    ///Idiomatic alias for [`Self::EDITION_PROTO3`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const EditionProto3: Self = Self::EDITION_PROTO3;
    ///Idiomatic alias for [`Self::EDITION_2023`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Edition2023: Self = Self::EDITION_2023;
    ///Idiomatic alias for [`Self::EDITION_2024`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Edition2024: Self = Self::EDITION_2024;
    ///Idiomatic alias for [`Self::EDITION_UNSTABLE`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const EditionUnstable: Self = Self::EDITION_UNSTABLE;
    ///Idiomatic alias for [`Self::EDITION_1_TEST_ONLY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Edition1TestOnly: Self = Self::EDITION_1_TEST_ONLY;
    ///Idiomatic alias for [`Self::EDITION_2_TEST_ONLY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Edition2TestOnly: Self = Self::EDITION_2_TEST_ONLY;
    ///Idiomatic alias for [`Self::EDITION_99997_TEST_ONLY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Edition99997TestOnly: Self = Self::EDITION_99997_TEST_ONLY;
    ///Idiomatic alias for [`Self::EDITION_99998_TEST_ONLY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Edition99998TestOnly: Self = Self::EDITION_99998_TEST_ONLY;
    ///Idiomatic alias for [`Self::EDITION_99999_TEST_ONLY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Edition99999TestOnly: Self = Self::EDITION_99999_TEST_ONLY;
    ///Idiomatic alias for [`Self::EDITION_MAX`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const EditionMax: Self = Self::EDITION_MAX;
}
impl ::core::default::Default for Edition {
    fn default() -> Self {
        Self::EDITION_UNKNOWN
    }
}
#[cfg(feature = "json")]
const _: () = {
    impl ::serde::Serialize for Edition {
        fn serialize<S: ::serde::Serializer>(
            &self,
            s: S,
        ) -> ::core::result::Result<S::Ok, S::Error> {
            s.serialize_str(::buffa::Enumeration::proto_name(self))
        }
    }
    impl<'de> ::serde::Deserialize<'de> for Edition {
        fn deserialize<D: ::serde::Deserializer<'de>>(
            d: D,
        ) -> ::core::result::Result<Self, D::Error> {
            struct _V;
            impl ::serde::de::Visitor<'_> for _V {
                type Value = Edition;
                fn expecting(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.write_str(
                        concat!("a string, integer, or null for ", stringify!(Edition)),
                    )
                }
                fn visit_str<E: ::serde::de::Error>(
                    self,
                    v: &str,
                ) -> ::core::result::Result<Edition, E> {
                    <Edition as ::buffa::Enumeration>::from_proto_name(v)
                        .ok_or_else(|| { ::serde::de::Error::unknown_variant(v, &[]) })
                }
                fn visit_i64<E: ::serde::de::Error>(
                    self,
                    v: i64,
                ) -> ::core::result::Result<Edition, E> {
                    let v32 = i32::try_from(v)
                        .map_err(|_| {
                            ::serde::de::Error::custom(
                                ::buffa::alloc::format!("enum value {v} out of i32 range"),
                            )
                        })?;
                    <Edition as ::buffa::Enumeration>::from_i32(v32)
                        .ok_or_else(|| {
                            ::serde::de::Error::custom(
                                ::buffa::alloc::format!("unknown enum value {v32}"),
                            )
                        })
                }
                fn visit_u64<E: ::serde::de::Error>(
                    self,
                    v: u64,
                ) -> ::core::result::Result<Edition, E> {
                    let v32 = i32::try_from(v)
                        .map_err(|_| {
                            ::serde::de::Error::custom(
                                ::buffa::alloc::format!("enum value {v} out of i32 range"),
                            )
                        })?;
                    <Edition as ::buffa::Enumeration>::from_i32(v32)
                        .ok_or_else(|| {
                            ::serde::de::Error::custom(
                                ::buffa::alloc::format!("unknown enum value {v32}"),
                            )
                        })
                }
                fn visit_unit<E: ::serde::de::Error>(
                    self,
                ) -> ::core::result::Result<Edition, E> {
                    ::core::result::Result::Ok(::core::default::Default::default())
                }
            }
            d.deserialize_any(_V)
        }
    }
    impl ::buffa::json_helpers::ProtoElemJson for Edition {
        fn serialize_proto_json<S: ::serde::Serializer>(
            v: &Self,
            s: S,
        ) -> ::core::result::Result<S::Ok, S::Error> {
            ::serde::Serialize::serialize(v, s)
        }
        fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
            d: D,
        ) -> ::core::result::Result<Self, D::Error> {
            <Self as ::serde::Deserialize>::deserialize(d)
        }
    }
};
impl ::buffa::Enumeration for Edition {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::EDITION_UNKNOWN),
            900i32 => ::core::option::Option::Some(Self::EDITION_LEGACY),
            998i32 => ::core::option::Option::Some(Self::EDITION_PROTO2),
            999i32 => ::core::option::Option::Some(Self::EDITION_PROTO3),
            1000i32 => ::core::option::Option::Some(Self::EDITION_2023),
            1001i32 => ::core::option::Option::Some(Self::EDITION_2024),
            9999i32 => ::core::option::Option::Some(Self::EDITION_UNSTABLE),
            1i32 => ::core::option::Option::Some(Self::EDITION_1_TEST_ONLY),
            2i32 => ::core::option::Option::Some(Self::EDITION_2_TEST_ONLY),
            99997i32 => ::core::option::Option::Some(Self::EDITION_99997_TEST_ONLY),
            99998i32 => ::core::option::Option::Some(Self::EDITION_99998_TEST_ONLY),
            99999i32 => ::core::option::Option::Some(Self::EDITION_99999_TEST_ONLY),
            2147483647i32 => ::core::option::Option::Some(Self::EDITION_MAX),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::EDITION_UNKNOWN => "EDITION_UNKNOWN",
            Self::EDITION_LEGACY => "EDITION_LEGACY",
            Self::EDITION_PROTO2 => "EDITION_PROTO2",
            Self::EDITION_PROTO3 => "EDITION_PROTO3",
            Self::EDITION_2023 => "EDITION_2023",
            Self::EDITION_2024 => "EDITION_2024",
            Self::EDITION_UNSTABLE => "EDITION_UNSTABLE",
            Self::EDITION_1_TEST_ONLY => "EDITION_1_TEST_ONLY",
            Self::EDITION_2_TEST_ONLY => "EDITION_2_TEST_ONLY",
            Self::EDITION_99997_TEST_ONLY => "EDITION_99997_TEST_ONLY",
            Self::EDITION_99998_TEST_ONLY => "EDITION_99998_TEST_ONLY",
            Self::EDITION_99999_TEST_ONLY => "EDITION_99999_TEST_ONLY",
            Self::EDITION_MAX => "EDITION_MAX",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "EDITION_UNKNOWN" => ::core::option::Option::Some(Self::EDITION_UNKNOWN),
            "EDITION_LEGACY" => ::core::option::Option::Some(Self::EDITION_LEGACY),
            "EDITION_PROTO2" => ::core::option::Option::Some(Self::EDITION_PROTO2),
            "EDITION_PROTO3" => ::core::option::Option::Some(Self::EDITION_PROTO3),
            "EDITION_2023" => ::core::option::Option::Some(Self::EDITION_2023),
            "EDITION_2024" => ::core::option::Option::Some(Self::EDITION_2024),
            "EDITION_UNSTABLE" => ::core::option::Option::Some(Self::EDITION_UNSTABLE),
            "EDITION_1_TEST_ONLY" => {
                ::core::option::Option::Some(Self::EDITION_1_TEST_ONLY)
            }
            "EDITION_2_TEST_ONLY" => {
                ::core::option::Option::Some(Self::EDITION_2_TEST_ONLY)
            }
            "EDITION_99997_TEST_ONLY" => {
                ::core::option::Option::Some(Self::EDITION_99997_TEST_ONLY)
            }
            "EDITION_99998_TEST_ONLY" => {
                ::core::option::Option::Some(Self::EDITION_99998_TEST_ONLY)
            }
            "EDITION_99999_TEST_ONLY" => {
                ::core::option::Option::Some(Self::EDITION_99999_TEST_ONLY)
            }
            "EDITION_MAX" => ::core::option::Option::Some(Self::EDITION_MAX),
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::EDITION_UNKNOWN,
            Self::EDITION_LEGACY,
            Self::EDITION_PROTO2,
            Self::EDITION_PROTO3,
            Self::EDITION_2023,
            Self::EDITION_2024,
            Self::EDITION_UNSTABLE,
            Self::EDITION_1_TEST_ONLY,
            Self::EDITION_2_TEST_ONLY,
            Self::EDITION_99997_TEST_ONLY,
            Self::EDITION_99998_TEST_ONLY,
            Self::EDITION_99999_TEST_ONLY,
            Self::EDITION_MAX,
        ]
    }
}
/// Describes the 'visibility' of a symbol with respect to the proto import
/// system. Symbols can only be imported when the visibility rules do not prevent
/// it (ex: local symbols cannot be imported).  Visibility modifiers can only set
/// on `message` and `enum` as they are the only types available to be referenced
/// from other files.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
#[repr(i32)]
pub enum SymbolVisibility {
    VISIBILITY_UNSET = 0i32,
    VISIBILITY_LOCAL = 1i32,
    VISIBILITY_EXPORT = 2i32,
}
impl SymbolVisibility {
    ///Idiomatic alias for [`Self::VISIBILITY_UNSET`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const VisibilityUnset: Self = Self::VISIBILITY_UNSET;
    ///Idiomatic alias for [`Self::VISIBILITY_LOCAL`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const VisibilityLocal: Self = Self::VISIBILITY_LOCAL;
    ///Idiomatic alias for [`Self::VISIBILITY_EXPORT`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const VisibilityExport: Self = Self::VISIBILITY_EXPORT;
}
impl ::core::default::Default for SymbolVisibility {
    fn default() -> Self {
        Self::VISIBILITY_UNSET
    }
}
#[cfg(feature = "json")]
const _: () = {
    impl ::serde::Serialize for SymbolVisibility {
        fn serialize<S: ::serde::Serializer>(
            &self,
            s: S,
        ) -> ::core::result::Result<S::Ok, S::Error> {
            s.serialize_str(::buffa::Enumeration::proto_name(self))
        }
    }
    impl<'de> ::serde::Deserialize<'de> for SymbolVisibility {
        fn deserialize<D: ::serde::Deserializer<'de>>(
            d: D,
        ) -> ::core::result::Result<Self, D::Error> {
            struct _V;
            impl ::serde::de::Visitor<'_> for _V {
                type Value = SymbolVisibility;
                fn expecting(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.write_str(
                        concat!(
                            "a string, integer, or null for ",
                            stringify!(SymbolVisibility)
                        ),
                    )
                }
                fn visit_str<E: ::serde::de::Error>(
                    self,
                    v: &str,
                ) -> ::core::result::Result<SymbolVisibility, E> {
                    <SymbolVisibility as ::buffa::Enumeration>::from_proto_name(v)
                        .ok_or_else(|| { ::serde::de::Error::unknown_variant(v, &[]) })
                }
                fn visit_i64<E: ::serde::de::Error>(
                    self,
                    v: i64,
                ) -> ::core::result::Result<SymbolVisibility, E> {
                    let v32 = i32::try_from(v)
                        .map_err(|_| {
                            ::serde::de::Error::custom(
                                ::buffa::alloc::format!("enum value {v} out of i32 range"),
                            )
                        })?;
                    <SymbolVisibility as ::buffa::Enumeration>::from_i32(v32)
                        .ok_or_else(|| {
                            ::serde::de::Error::custom(
                                ::buffa::alloc::format!("unknown enum value {v32}"),
                            )
                        })
                }
                fn visit_u64<E: ::serde::de::Error>(
                    self,
                    v: u64,
                ) -> ::core::result::Result<SymbolVisibility, E> {
                    let v32 = i32::try_from(v)
                        .map_err(|_| {
                            ::serde::de::Error::custom(
                                ::buffa::alloc::format!("enum value {v} out of i32 range"),
                            )
                        })?;
                    <SymbolVisibility as ::buffa::Enumeration>::from_i32(v32)
                        .ok_or_else(|| {
                            ::serde::de::Error::custom(
                                ::buffa::alloc::format!("unknown enum value {v32}"),
                            )
                        })
                }
                fn visit_unit<E: ::serde::de::Error>(
                    self,
                ) -> ::core::result::Result<SymbolVisibility, E> {
                    ::core::result::Result::Ok(::core::default::Default::default())
                }
            }
            d.deserialize_any(_V)
        }
    }
    impl ::buffa::json_helpers::ProtoElemJson for SymbolVisibility {
        fn serialize_proto_json<S: ::serde::Serializer>(
            v: &Self,
            s: S,
        ) -> ::core::result::Result<S::Ok, S::Error> {
            ::serde::Serialize::serialize(v, s)
        }
        fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
            d: D,
        ) -> ::core::result::Result<Self, D::Error> {
            <Self as ::serde::Deserialize>::deserialize(d)
        }
    }
};
impl ::buffa::Enumeration for SymbolVisibility {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::VISIBILITY_UNSET),
            1i32 => ::core::option::Option::Some(Self::VISIBILITY_LOCAL),
            2i32 => ::core::option::Option::Some(Self::VISIBILITY_EXPORT),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::VISIBILITY_UNSET => "VISIBILITY_UNSET",
            Self::VISIBILITY_LOCAL => "VISIBILITY_LOCAL",
            Self::VISIBILITY_EXPORT => "VISIBILITY_EXPORT",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "VISIBILITY_UNSET" => ::core::option::Option::Some(Self::VISIBILITY_UNSET),
            "VISIBILITY_LOCAL" => ::core::option::Option::Some(Self::VISIBILITY_LOCAL),
            "VISIBILITY_EXPORT" => ::core::option::Option::Some(Self::VISIBILITY_EXPORT),
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[Self::VISIBILITY_UNSET, Self::VISIBILITY_LOCAL, Self::VISIBILITY_EXPORT]
    }
}
/// The protocol compiler can output a FileDescriptorSet containing the .proto
/// files it parses.
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct FileDescriptorSet {
    /// Field 1: `file`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "file",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub file: ::buffa::alloc::vec::Vec<FileDescriptorProto>,
    #[cfg_attr(feature = "json", serde(flatten))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: __FileDescriptorSetExtJson,
}
impl ::core::fmt::Debug for FileDescriptorSet {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("FileDescriptorSet").field("file", &self.file).finish()
    }
}
impl FileDescriptorSet {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FileDescriptorSet";
}
::buffa::impl_default_instance!(FileDescriptorSet);
impl ::buffa::MessageName for FileDescriptorSet {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "FileDescriptorSet";
    const FULL_NAME: &'static str = "google.protobuf.FileDescriptorSet";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FileDescriptorSet";
}
impl ::buffa::Message for FileDescriptorSet {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        for v in &self.file {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for v in &self.file {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.file.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.file.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for FileDescriptorSet {
    const PROTO_FQN: &'static str = "google.protobuf.FileDescriptorSet";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for FileDescriptorSet {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for __v in &self.file {
            enc.write_field_name("file")?;
            enc.write_message(__v)?;
        }
        enc.write_extension_fields(
            "google.protobuf.FileDescriptorSet",
            &self.__buffa_unknown_fields,
        )?;
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "file" => {
                    dec.read_repeated_into(
                        &mut self.file,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                __name if __name.starts_with('[') => {
                    for __r in dec
                        .read_extension(__name, "google.protobuf.FileDescriptorSet")?
                    {
                        self.__buffa_unknown_fields.push(__r);
                    }
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl<'de> serde::Deserialize<'de> for FileDescriptorSet {
    fn deserialize<D: serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl<'de> serde::de::Visitor<'de> for _V {
            type Value = FileDescriptorSet;
            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                f.write_str("struct FileDescriptorSet")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<FileDescriptorSet, A::Error> {
                let mut __f_file: ::core::option::Option<
                    ::buffa::alloc::vec::Vec<FileDescriptorProto>,
                > = None;
                let mut __ext_records: ::buffa::alloc::vec::Vec<::buffa::UnknownField> = ::buffa::alloc::vec::Vec::new();
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "file" => {
                            __f_file = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::buffa::alloc::vec::Vec<FileDescriptorProto>;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::buffa::alloc::vec::Vec<FileDescriptorProto>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::null_as_default(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        __k if __k.starts_with('[') => {
                            let __v: ::buffa::serde_json::Value = map.next_value()?;
                            match ::buffa::extension_registry::deserialize_extension_key(
                                "google.protobuf.FileDescriptorSet",
                                __k,
                                __v,
                            ) {
                                ::core::option::Option::Some(
                                    ::core::result::Result::Ok(__recs),
                                ) => {
                                    for __rec in __recs {
                                        __ext_records.push(__rec);
                                    }
                                }
                                ::core::option::Option::Some(
                                    ::core::result::Result::Err(__e),
                                ) => {
                                    return ::core::result::Result::Err(
                                        <A::Error as ::serde::de::Error>::custom(__e),
                                    );
                                }
                                ::core::option::Option::None => {}
                            }
                        }
                        _ => {
                            map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                let mut __r = <FileDescriptorSet as ::core::default::Default>::default();
                if let ::core::option::Option::Some(v) = __f_file {
                    __r.file = v;
                }
                for __rec in __ext_records {
                    __r.__buffa_unknown_fields.push(__rec);
                }
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for FileDescriptorSet {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
#[derive(Clone, Debug, Default, PartialEq)]
#[repr(transparent)]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct __FileDescriptorSetExtJson(pub ::buffa::UnknownFields);
impl ::core::ops::Deref for __FileDescriptorSetExtJson {
    type Target = ::buffa::UnknownFields;
    fn deref(&self) -> &::buffa::UnknownFields {
        &self.0
    }
}
impl ::core::ops::DerefMut for __FileDescriptorSetExtJson {
    fn deref_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.0
    }
}
impl ::core::convert::From<::buffa::UnknownFields> for __FileDescriptorSetExtJson {
    fn from(u: ::buffa::UnknownFields) -> Self {
        Self(u)
    }
}
#[cfg(feature = "json")]
impl ::serde::Serialize for __FileDescriptorSetExtJson {
    fn serialize<S: ::serde::Serializer>(
        &self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::buffa::extension_registry::serialize_extensions(
            "google.protobuf.FileDescriptorSet",
            &self.0,
            s,
        )
    }
}
#[cfg(feature = "json")]
impl<'de> ::serde::Deserialize<'de> for __FileDescriptorSetExtJson {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        ::buffa::extension_registry::deserialize_extensions(
                "google.protobuf.FileDescriptorSet",
                d,
            )
            .map(Self)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __FILE_DESCRIPTOR_SET_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.FileDescriptorSet",
    to_json: ::buffa::type_registry::any_to_json::<FileDescriptorSet>,
    from_json: ::buffa::type_registry::any_from_json::<FileDescriptorSet>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __FILE_DESCRIPTOR_SET_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.FileDescriptorSet",
    text_encode: ::buffa::type_registry::any_encode_text::<FileDescriptorSet>,
    text_merge: ::buffa::type_registry::any_merge_text::<FileDescriptorSet>,
};
/// Describes a complete .proto file.
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct FileDescriptorProto {
    /// file name, relative to root of source tree
    ///
    /// Field 1: `name`
    #[cfg_attr(
        feature = "json",
        serde(rename = "name", skip_serializing_if = "::core::option::Option::is_none")
    )]
    pub name: ::core::option::Option<::buffa::alloc::string::String>,
    /// e.g. "foo", "foo.bar", etc.
    ///
    /// Field 2: `package`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "package",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub package: ::core::option::Option<::buffa::alloc::string::String>,
    /// Names of files imported by this file.
    ///
    /// Field 3: `dependency`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "dependency",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub dependency: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
    /// Indexes of the public imported files in the dependency list above.
    ///
    /// Field 10: `public_dependency`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "publicDependency",
            alias = "public_dependency",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub public_dependency: ::buffa::alloc::vec::Vec<i32>,
    /// Indexes of the weak imported files in the dependency list.
    /// For Google-internal migration only. Do not use.
    ///
    /// Field 11: `weak_dependency`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "weakDependency",
            alias = "weak_dependency",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub weak_dependency: ::buffa::alloc::vec::Vec<i32>,
    /// Names of files imported by this file purely for the purpose of providing
    /// option extensions. These are excluded from the dependency list above.
    ///
    /// Field 15: `option_dependency`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "optionDependency",
            alias = "option_dependency",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub option_dependency: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
    /// All top-level definitions in this file.
    ///
    /// Field 4: `message_type`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "messageType",
            alias = "message_type",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub message_type: ::buffa::alloc::vec::Vec<DescriptorProto>,
    /// Field 5: `enum_type`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "enumType",
            alias = "enum_type",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub enum_type: ::buffa::alloc::vec::Vec<EnumDescriptorProto>,
    /// Field 6: `service`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "service",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub service: ::buffa::alloc::vec::Vec<ServiceDescriptorProto>,
    /// Field 7: `extension`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "extension",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub extension: ::buffa::alloc::vec::Vec<FieldDescriptorProto>,
    /// Field 8: `options`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "options",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub options: ::buffa::MessageField<FileOptions, ::buffa::Inline<FileOptions>>,
    /// This field contains optional information about the original source code.
    /// You may safely remove this entire field without harming runtime
    /// functionality of the descriptors -- the information is needed only by
    /// development tools.
    ///
    /// Field 9: `source_code_info`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "sourceCodeInfo",
            alias = "source_code_info",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub source_code_info: ::buffa::MessageField<
        SourceCodeInfo,
        ::buffa::Inline<SourceCodeInfo>,
    >,
    /// The syntax of the proto file.
    /// The supported values are "proto2", "proto3", and "editions".
    ///
    /// If `edition` is present, this value must be "editions".
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    ///
    /// Field 12: `syntax`
    #[cfg_attr(
        feature = "json",
        serde(rename = "syntax", skip_serializing_if = "::core::option::Option::is_none")
    )]
    pub syntax: ::core::option::Option<::buffa::alloc::string::String>,
    /// The edition of the proto file.
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    ///
    /// Field 14: `edition`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "edition",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub edition: ::core::option::Option<Edition>,
    #[cfg_attr(feature = "json", serde(skip))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for FileDescriptorProto {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("FileDescriptorProto")
            .field("name", &self.name)
            .field("package", &self.package)
            .field("dependency", &self.dependency)
            .field("public_dependency", &self.public_dependency)
            .field("weak_dependency", &self.weak_dependency)
            .field("option_dependency", &self.option_dependency)
            .field("message_type", &self.message_type)
            .field("enum_type", &self.enum_type)
            .field("service", &self.service)
            .field("extension", &self.extension)
            .field("options", &self.options)
            .field("source_code_info", &self.source_code_info)
            .field("syntax", &self.syntax)
            .field("edition", &self.edition)
            .finish()
    }
}
impl FileDescriptorProto {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FileDescriptorProto";
}
impl FileDescriptorProto {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::name`] to `Some(value)`, consuming and returning `self`.
    pub fn with_name(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.name = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::package`] to `Some(value)`, consuming and returning `self`.
    pub fn with_package(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.package = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::syntax`] to `Some(value)`, consuming and returning `self`.
    pub fn with_syntax(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.syntax = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::edition`] to `Some(value)`, consuming and returning `self`.
    pub fn with_edition(mut self, value: impl Into<Edition>) -> Self {
        self.edition = Some(value.into());
        self
    }
}
::buffa::impl_default_instance!(FileDescriptorProto);
impl ::buffa::MessageName for FileDescriptorProto {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "FileDescriptorProto";
    const FULL_NAME: &'static str = "google.protobuf.FileDescriptorProto";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FileDescriptorProto";
}
impl ::buffa::Message for FileDescriptorProto {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if let Some(ref v) = self.name {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.package {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        for v in &self.dependency {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        for v in &self.message_type {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.enum_type {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.service {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.extension {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if self.options.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.options.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if self.source_code_info.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.source_code_info.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.public_dependency {
            size += 1u64 + ::buffa::types::int32_encoded_len(*v) as u64;
        }
        for v in &self.weak_dependency {
            size += 1u64 + ::buffa::types::int32_encoded_len(*v) as u64;
        }
        if let Some(ref v) = self.syntax {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.edition {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        for v in &self.option_dependency {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let Some(ref v) = self.name {
            ::buffa::types::put_string_field(1u32, v, buf);
        }
        if let Some(ref v) = self.package {
            ::buffa::types::put_string_field(2u32, v, buf);
        }
        for v in &self.dependency {
            ::buffa::types::put_string_field(3u32, v, buf);
        }
        for v in &self.message_type {
            ::buffa::types::put_len_delimited_header(
                4u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        for v in &self.enum_type {
            ::buffa::types::put_len_delimited_header(
                5u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        for v in &self.service {
            ::buffa::types::put_len_delimited_header(
                6u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        for v in &self.extension {
            ::buffa::types::put_len_delimited_header(
                7u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        if self.options.is_set() {
            ::buffa::types::put_len_delimited_header(
                8u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.options.write_to(__cache, buf);
        }
        if self.source_code_info.is_set() {
            ::buffa::types::put_len_delimited_header(
                9u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.source_code_info.write_to(__cache, buf);
        }
        for v in &self.public_dependency {
            ::buffa::types::put_int32_field(10u32, *v, buf);
        }
        for v in &self.weak_dependency {
            ::buffa::types::put_int32_field(11u32, *v, buf);
        }
        if let Some(ref v) = self.syntax {
            ::buffa::types::put_string_field(12u32, v, buf);
        }
        if let Some(ref v) = self.edition {
            ::buffa::types::put_int32_field(14u32, v.to_i32(), buf);
        }
        for v in &self.option_dependency {
            ::buffa::types::put_string_field(15u32, v, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self.name.get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self.package.get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __elem = ::buffa::types::decode_string(buf)?;
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&__elem),
                )?;
                self.dependency.push(__elem);
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.message_type.push(elem);
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.enum_type.push(elem);
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.service.push(elem);
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.extension.push(elem);
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.options.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            9u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.source_code_info.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            10u32 => {
                if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
                    let len = ::buffa::encoding::decode_varint(buf)?;
                    let len = usize::try_from(len)
                        .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
                    if buf.remaining() < len {
                        return ::core::result::Result::Err(
                            ::buffa::DecodeError::UnexpectedEof,
                        );
                    }
                    if buf.chunk().len() >= len {
                        ::buffa::types::extend_packed_int32(
                            &buf.chunk()[..len],
                            &mut self.public_dependency,
                            len,
                        )?;
                        buf.advance(len);
                    } else {
                        self.public_dependency.reserve(len);
                        let mut limited = buf.take(len);
                        while limited.has_remaining() {
                            self.public_dependency
                                .push(::buffa::types::decode_int32_packed(&mut limited)?);
                        }
                        let leftover = limited.remaining();
                        if leftover > 0 {
                            limited.advance(leftover);
                        }
                    }
                } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
                    self.public_dependency.push(::buffa::types::decode_int32(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            11u32 => {
                if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
                    let len = ::buffa::encoding::decode_varint(buf)?;
                    let len = usize::try_from(len)
                        .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
                    if buf.remaining() < len {
                        return ::core::result::Result::Err(
                            ::buffa::DecodeError::UnexpectedEof,
                        );
                    }
                    if buf.chunk().len() >= len {
                        ::buffa::types::extend_packed_int32(
                            &buf.chunk()[..len],
                            &mut self.weak_dependency,
                            len,
                        )?;
                        buf.advance(len);
                    } else {
                        self.weak_dependency.reserve(len);
                        let mut limited = buf.take(len);
                        while limited.has_remaining() {
                            self.weak_dependency
                                .push(::buffa::types::decode_int32_packed(&mut limited)?);
                        }
                        let leftover = limited.remaining();
                        if leftover > 0 {
                            limited.advance(leftover);
                        }
                    }
                } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
                    self.weak_dependency.push(::buffa::types::decode_int32(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            12u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self.syntax.get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            14u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.edition = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 14u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            15u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __elem = ::buffa::types::decode_string(buf)?;
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&__elem),
                )?;
                self.option_dependency.push(__elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.name = ::core::option::Option::None;
        self.package = ::core::option::Option::None;
        self.dependency.clear();
        self.message_type.clear();
        self.enum_type.clear();
        self.service.clear();
        self.extension.clear();
        self.options = ::buffa::MessageField::none();
        self.source_code_info = ::buffa::MessageField::none();
        self.public_dependency.clear();
        self.weak_dependency.clear();
        self.syntax = ::core::option::Option::None;
        self.edition = ::core::option::Option::None;
        self.option_dependency.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for FileDescriptorProto {
    const PROTO_FQN: &'static str = "google.protobuf.FileDescriptorProto";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for FileDescriptorProto {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref __v) = self.name {
            enc.write_field_name("name")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.package {
            enc.write_field_name("package")?;
            enc.write_string(__v)?;
        }
        if self.options.is_set() {
            enc.write_field_name("options")?;
            enc.write_message(&*self.options)?;
        }
        if self.source_code_info.is_set() {
            enc.write_field_name("source_code_info")?;
            enc.write_message(&*self.source_code_info)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.syntax {
            enc.write_field_name("syntax")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.edition {
            enc.write_field_name("edition")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        for __v in &self.dependency {
            enc.write_field_name("dependency")?;
            enc.write_string(__v)?;
        }
        for __v in &self.public_dependency {
            enc.write_field_name("public_dependency")?;
            enc.write_i32(*__v)?;
        }
        for __v in &self.weak_dependency {
            enc.write_field_name("weak_dependency")?;
            enc.write_i32(*__v)?;
        }
        for __v in &self.option_dependency {
            enc.write_field_name("option_dependency")?;
            enc.write_string(__v)?;
        }
        for __v in &self.message_type {
            enc.write_field_name("message_type")?;
            enc.write_message(__v)?;
        }
        for __v in &self.enum_type {
            enc.write_field_name("enum_type")?;
            enc.write_message(__v)?;
        }
        for __v in &self.service {
            enc.write_field_name("service")?;
            enc.write_message(__v)?;
        }
        for __v in &self.extension {
            enc.write_field_name("extension")?;
            enc.write_message(__v)?;
        }
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "name" => {
                    self.name = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "package" => {
                    self.package = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "options" => dec.merge_message(self.options.get_or_insert_default())?,
                "source_code_info" => {
                    dec.merge_message(self.source_code_info.get_or_insert_default())?
                }
                "syntax" => {
                    self.syntax = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "edition" => {
                    self.edition = ::core::option::Option::Some(
                        dec.read_closed_enum_by_name::<Edition>()?,
                    );
                }
                "dependency" => {
                    dec.read_repeated_into(
                        &mut self.dependency,
                        |__d| ::core::result::Result::Ok(__d.read_string()?.into_owned()),
                    )?
                }
                "public_dependency" => {
                    dec.read_repeated_into(
                        &mut self.public_dependency,
                        |__d| __d.read_i32(),
                    )?
                }
                "weak_dependency" => {
                    dec.read_repeated_into(
                        &mut self.weak_dependency,
                        |__d| __d.read_i32(),
                    )?
                }
                "option_dependency" => {
                    dec.read_repeated_into(
                        &mut self.option_dependency,
                        |__d| ::core::result::Result::Ok(__d.read_string()?.into_owned()),
                    )?
                }
                "message_type" => {
                    dec.read_repeated_into(
                        &mut self.message_type,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                "enum_type" => {
                    dec.read_repeated_into(
                        &mut self.enum_type,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                "service" => {
                    dec.read_repeated_into(
                        &mut self.service,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                "extension" => {
                    dec.read_repeated_into(
                        &mut self.extension,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for FileDescriptorProto {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __FILE_DESCRIPTOR_PROTO_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.FileDescriptorProto",
    to_json: ::buffa::type_registry::any_to_json::<FileDescriptorProto>,
    from_json: ::buffa::type_registry::any_from_json::<FileDescriptorProto>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __FILE_DESCRIPTOR_PROTO_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.FileDescriptorProto",
    text_encode: ::buffa::type_registry::any_encode_text::<FileDescriptorProto>,
    text_merge: ::buffa::type_registry::any_merge_text::<FileDescriptorProto>,
};
/// Describes a message type.
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct DescriptorProto {
    /// Field 1: `name`
    #[cfg_attr(
        feature = "json",
        serde(rename = "name", skip_serializing_if = "::core::option::Option::is_none")
    )]
    pub name: ::core::option::Option<::buffa::alloc::string::String>,
    /// Field 2: `field`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "field",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub field: ::buffa::alloc::vec::Vec<FieldDescriptorProto>,
    /// Field 6: `extension`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "extension",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub extension: ::buffa::alloc::vec::Vec<FieldDescriptorProto>,
    /// Field 3: `nested_type`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "nestedType",
            alias = "nested_type",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub nested_type: ::buffa::alloc::vec::Vec<Self>,
    /// Field 4: `enum_type`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "enumType",
            alias = "enum_type",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub enum_type: ::buffa::alloc::vec::Vec<EnumDescriptorProto>,
    /// Field 5: `extension_range`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "extensionRange",
            alias = "extension_range",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub extension_range: ::buffa::alloc::vec::Vec<descriptor_proto::ExtensionRange>,
    /// Field 8: `oneof_decl`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "oneofDecl",
            alias = "oneof_decl",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub oneof_decl: ::buffa::alloc::vec::Vec<OneofDescriptorProto>,
    /// Field 7: `options`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "options",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub options: ::buffa::MessageField<MessageOptions, ::buffa::Inline<MessageOptions>>,
    /// Field 9: `reserved_range`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "reservedRange",
            alias = "reserved_range",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub reserved_range: ::buffa::alloc::vec::Vec<descriptor_proto::ReservedRange>,
    /// Reserved field names, which may not be used by fields in the same message.
    /// A given name may only be reserved once.
    ///
    /// Field 10: `reserved_name`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "reservedName",
            alias = "reserved_name",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub reserved_name: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
    /// Support for `export` and `local` keywords on enums.
    ///
    /// Field 11: `visibility`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "visibility",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub visibility: ::core::option::Option<SymbolVisibility>,
    #[cfg_attr(feature = "json", serde(skip))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for DescriptorProto {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("DescriptorProto")
            .field("name", &self.name)
            .field("field", &self.field)
            .field("extension", &self.extension)
            .field("nested_type", &self.nested_type)
            .field("enum_type", &self.enum_type)
            .field("extension_range", &self.extension_range)
            .field("oneof_decl", &self.oneof_decl)
            .field("options", &self.options)
            .field("reserved_range", &self.reserved_range)
            .field("reserved_name", &self.reserved_name)
            .field("visibility", &self.visibility)
            .finish()
    }
}
impl DescriptorProto {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.DescriptorProto";
}
impl DescriptorProto {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::name`] to `Some(value)`, consuming and returning `self`.
    pub fn with_name(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.name = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::visibility`] to `Some(value)`, consuming and returning `self`.
    pub fn with_visibility(mut self, value: impl Into<SymbolVisibility>) -> Self {
        self.visibility = Some(value.into());
        self
    }
}
::buffa::impl_default_instance!(DescriptorProto);
impl ::buffa::MessageName for DescriptorProto {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "DescriptorProto";
    const FULL_NAME: &'static str = "google.protobuf.DescriptorProto";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.DescriptorProto";
}
impl ::buffa::Message for DescriptorProto {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if let Some(ref v) = self.name {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        for v in &self.field {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.nested_type {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.enum_type {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.extension_range {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.extension {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if self.options.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.options.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.oneof_decl {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.reserved_range {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.reserved_name {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.visibility {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let Some(ref v) = self.name {
            ::buffa::types::put_string_field(1u32, v, buf);
        }
        for v in &self.field {
            ::buffa::types::put_len_delimited_header(
                2u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        for v in &self.nested_type {
            ::buffa::types::put_len_delimited_header(
                3u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        for v in &self.enum_type {
            ::buffa::types::put_len_delimited_header(
                4u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        for v in &self.extension_range {
            ::buffa::types::put_len_delimited_header(
                5u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        for v in &self.extension {
            ::buffa::types::put_len_delimited_header(
                6u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        if self.options.is_set() {
            ::buffa::types::put_len_delimited_header(
                7u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.options.write_to(__cache, buf);
        }
        for v in &self.oneof_decl {
            ::buffa::types::put_len_delimited_header(
                8u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        for v in &self.reserved_range {
            ::buffa::types::put_len_delimited_header(
                9u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        for v in &self.reserved_name {
            ::buffa::types::put_string_field(10u32, v, buf);
        }
        if let Some(ref v) = self.visibility {
            ::buffa::types::put_int32_field(11u32, v.to_i32(), buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self.name.get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.field.push(elem);
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.nested_type.push(elem);
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.enum_type.push(elem);
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.extension_range.push(elem);
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.extension.push(elem);
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.options.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.oneof_decl.push(elem);
            }
            9u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.reserved_range.push(elem);
            }
            10u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __elem = ::buffa::types::decode_string(buf)?;
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&__elem),
                )?;
                self.reserved_name.push(__elem);
            }
            11u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.visibility = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 11u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.name = ::core::option::Option::None;
        self.field.clear();
        self.nested_type.clear();
        self.enum_type.clear();
        self.extension_range.clear();
        self.extension.clear();
        self.options = ::buffa::MessageField::none();
        self.oneof_decl.clear();
        self.reserved_range.clear();
        self.reserved_name.clear();
        self.visibility = ::core::option::Option::None;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for DescriptorProto {
    const PROTO_FQN: &'static str = "google.protobuf.DescriptorProto";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for DescriptorProto {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref __v) = self.name {
            enc.write_field_name("name")?;
            enc.write_string(__v)?;
        }
        if self.options.is_set() {
            enc.write_field_name("options")?;
            enc.write_message(&*self.options)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.visibility {
            enc.write_field_name("visibility")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        for __v in &self.field {
            enc.write_field_name("field")?;
            enc.write_message(__v)?;
        }
        for __v in &self.extension {
            enc.write_field_name("extension")?;
            enc.write_message(__v)?;
        }
        for __v in &self.nested_type {
            enc.write_field_name("nested_type")?;
            enc.write_message(__v)?;
        }
        for __v in &self.enum_type {
            enc.write_field_name("enum_type")?;
            enc.write_message(__v)?;
        }
        for __v in &self.extension_range {
            enc.write_field_name("extension_range")?;
            enc.write_message(__v)?;
        }
        for __v in &self.oneof_decl {
            enc.write_field_name("oneof_decl")?;
            enc.write_message(__v)?;
        }
        for __v in &self.reserved_range {
            enc.write_field_name("reserved_range")?;
            enc.write_message(__v)?;
        }
        for __v in &self.reserved_name {
            enc.write_field_name("reserved_name")?;
            enc.write_string(__v)?;
        }
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "name" => {
                    self.name = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "options" => dec.merge_message(self.options.get_or_insert_default())?,
                "visibility" => {
                    self.visibility = ::core::option::Option::Some(
                        dec.read_closed_enum_by_name::<SymbolVisibility>()?,
                    );
                }
                "field" => {
                    dec.read_repeated_into(
                        &mut self.field,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                "extension" => {
                    dec.read_repeated_into(
                        &mut self.extension,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                "nested_type" => {
                    dec.read_repeated_into(
                        &mut self.nested_type,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                "enum_type" => {
                    dec.read_repeated_into(
                        &mut self.enum_type,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                "extension_range" => {
                    dec.read_repeated_into(
                        &mut self.extension_range,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                "oneof_decl" => {
                    dec.read_repeated_into(
                        &mut self.oneof_decl,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                "reserved_range" => {
                    dec.read_repeated_into(
                        &mut self.reserved_range,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                "reserved_name" => {
                    dec.read_repeated_into(
                        &mut self.reserved_name,
                        |__d| ::core::result::Result::Ok(__d.read_string()?.into_owned()),
                    )?
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for DescriptorProto {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __DESCRIPTOR_PROTO_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.DescriptorProto",
    to_json: ::buffa::type_registry::any_to_json::<DescriptorProto>,
    from_json: ::buffa::type_registry::any_from_json::<DescriptorProto>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __DESCRIPTOR_PROTO_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.DescriptorProto",
    text_encode: ::buffa::type_registry::any_encode_text::<DescriptorProto>,
    text_merge: ::buffa::type_registry::any_merge_text::<DescriptorProto>,
};
pub mod descriptor_proto {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, PartialEq, Default)]
    #[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
    #[cfg_attr(feature = "json", serde(default))]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    pub struct ExtensionRange {
        /// Inclusive.
        ///
        /// Field 1: `start`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "start",
                with = "::buffa::json_helpers::opt_int32",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub start: ::core::option::Option<i32>,
        /// Exclusive.
        ///
        /// Field 2: `end`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "end",
                with = "::buffa::json_helpers::opt_int32",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub end: ::core::option::Option<i32>,
        /// Field 3: `options`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "options",
                skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
            )
        )]
        pub options: ::buffa::MessageField<
            super::ExtensionRangeOptions,
            ::buffa::Inline<super::ExtensionRangeOptions>,
        >,
        #[cfg_attr(feature = "json", serde(skip))]
        #[doc(hidden)]
        pub __buffa_unknown_fields: ::buffa::UnknownFields,
    }
    impl ::core::fmt::Debug for ExtensionRange {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            f.debug_struct("ExtensionRange")
                .field("start", &self.start)
                .field("end", &self.end)
                .field("options", &self.options)
                .finish()
        }
    }
    impl ExtensionRange {
        /// Protobuf type URL for this message, for use with `Any::pack` and
        /// `Any::unpack_if`.
        ///
        /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
        pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.DescriptorProto.ExtensionRange";
    }
    impl ExtensionRange {
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::start`] to `Some(value)`, consuming and returning `self`.
        pub fn with_start(mut self, value: i32) -> Self {
            self.start = Some(value);
            self
        }
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::end`] to `Some(value)`, consuming and returning `self`.
        pub fn with_end(mut self, value: i32) -> Self {
            self.end = Some(value);
            self
        }
    }
    ::buffa::impl_default_instance!(ExtensionRange);
    impl ::buffa::MessageName for ExtensionRange {
        const PACKAGE: &'static str = "google.protobuf";
        const NAME: &'static str = "DescriptorProto.ExtensionRange";
        const FULL_NAME: &'static str = "google.protobuf.DescriptorProto.ExtensionRange";
        const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.DescriptorProto.ExtensionRange";
    }
    impl ::buffa::Message for ExtensionRange {
        /// Returns the total encoded size in bytes.
        ///
        /// Accumulates in `u64` (which cannot overflow for in-memory
        /// data) and saturates to `u32` at return, so a message whose
        /// encoded size exceeds the 2 GiB protobuf limit yields a value
        /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
        /// points reject, never a silently wrapped size.
        #[allow(clippy::let_and_return)]
        fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            let mut size = 0u64;
            if let Some(v) = self.start {
                size += 1u64 + ::buffa::types::int32_encoded_len(v) as u64;
            }
            if let Some(v) = self.end {
                size += 1u64 + ::buffa::types::int32_encoded_len(v) as u64;
            }
            if self.options.is_set() {
                let __slot = __cache.reserve();
                let inner_size = self.options.compute_size(__cache);
                __cache.set(__slot, inner_size);
                size
                    += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                        + inner_size as u64;
            }
            size += self.__buffa_unknown_fields.encoded_len() as u64;
            ::buffa::saturate_size(size)
        }
        fn write_to(
            &self,
            __cache: &mut ::buffa::SizeCache,
            buf: &mut impl ::buffa::EncodeSink,
        ) {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if let Some(v) = self.start {
                ::buffa::types::put_int32_field(1u32, v, buf);
            }
            if let Some(v) = self.end {
                ::buffa::types::put_int32_field(2u32, v, buf);
            }
            if self.options.is_set() {
                ::buffa::types::put_len_delimited_header(
                    3u32,
                    u64::from(__cache.consume_next()),
                    buf,
                );
                self.options.write_to(__cache, buf);
            }
            self.__buffa_unknown_fields.write_to(buf);
        }
        fn merge_field(
            &mut self,
            tag: ::buffa::encoding::Tag,
            buf: &mut impl ::buffa::bytes::Buf,
            ctx: ::buffa::DecodeContext<'_>,
        ) -> ::core::result::Result<(), ::buffa::DecodeError> {
            #[allow(unused_imports)]
            use ::buffa::bytes::Buf as _;
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            match tag.field_number() {
                1u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::Varint,
                    )?;
                    self.start = ::core::option::Option::Some(
                        ::buffa::types::decode_int32(buf)?,
                    );
                }
                2u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::Varint,
                    )?;
                    self.end = ::core::option::Option::Some(
                        ::buffa::types::decode_int32(buf)?,
                    );
                }
                3u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::LengthDelimited,
                    )?;
                    ::buffa::Message::merge_length_delimited(
                        self.options.get_or_insert_default(),
                        buf,
                        ctx,
                    )?;
                }
                _ => {
                    self.__buffa_unknown_fields
                        .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
                }
            }
            ::core::result::Result::Ok(())
        }
        fn clear(&mut self) {
            self.start = ::core::option::Option::None;
            self.end = ::core::option::Option::None;
            self.options = ::buffa::MessageField::none();
            self.__buffa_unknown_fields.clear();
        }
    }
    impl ::buffa::ExtensionSet for ExtensionRange {
        const PROTO_FQN: &'static str = "google.protobuf.DescriptorProto.ExtensionRange";
        fn unknown_fields(&self) -> &::buffa::UnknownFields {
            &self.__buffa_unknown_fields
        }
        fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
            &mut self.__buffa_unknown_fields
        }
    }
    #[cfg(feature = "text")]
    impl ::buffa::text::TextFormat for ExtensionRange {
        fn encode_text(
            &self,
            enc: &mut ::buffa::text::TextEncoder<'_>,
        ) -> ::core::fmt::Result {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if let ::core::option::Option::Some(ref __v) = self.start {
                enc.write_field_name("start")?;
                enc.write_i32(*__v)?;
            }
            if let ::core::option::Option::Some(ref __v) = self.end {
                enc.write_field_name("end")?;
                enc.write_i32(*__v)?;
            }
            if self.options.is_set() {
                enc.write_field_name("options")?;
                enc.write_message(&*self.options)?;
            }
            enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
            ::core::result::Result::Ok(())
        }
        fn merge_text(
            &mut self,
            dec: &mut ::buffa::text::TextDecoder<'_>,
        ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
                match __name {
                    "start" => self.start = ::core::option::Option::Some(dec.read_i32()?),
                    "end" => self.end = ::core::option::Option::Some(dec.read_i32()?),
                    "options" => dec.merge_message(self.options.get_or_insert_default())?,
                    _ => dec.skip_value()?,
                }
            }
            ::core::result::Result::Ok(())
        }
    }
    #[cfg(feature = "json")]
    impl ::buffa::json_helpers::ProtoElemJson for ExtensionRange {
        fn serialize_proto_json<S: ::serde::Serializer>(
            v: &Self,
            s: S,
        ) -> ::core::result::Result<S::Ok, S::Error> {
            ::serde::Serialize::serialize(v, s)
        }
        fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
            d: D,
        ) -> ::core::result::Result<Self, D::Error> {
            <Self as ::serde::Deserialize>::deserialize(d)
        }
    }
    #[cfg(feature = "json")]
    #[doc(hidden)]
    pub const __EXTENSION_RANGE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.DescriptorProto.ExtensionRange",
        to_json: ::buffa::type_registry::any_to_json::<ExtensionRange>,
        from_json: ::buffa::type_registry::any_from_json::<ExtensionRange>,
        is_wkt: false,
    };
    #[cfg(feature = "text")]
    #[doc(hidden)]
    pub const __EXTENSION_RANGE_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.DescriptorProto.ExtensionRange",
        text_encode: ::buffa::type_registry::any_encode_text::<ExtensionRange>,
        text_merge: ::buffa::type_registry::any_merge_text::<ExtensionRange>,
    };
    /// Range of reserved tag numbers. Reserved tag numbers may not be used by
    /// fields or extension ranges in the same message. Reserved ranges may
    /// not overlap.
    #[derive(Clone, PartialEq, Default)]
    #[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
    #[cfg_attr(feature = "json", serde(default))]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    pub struct ReservedRange {
        /// Inclusive.
        ///
        /// Field 1: `start`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "start",
                with = "::buffa::json_helpers::opt_int32",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub start: ::core::option::Option<i32>,
        /// Exclusive.
        ///
        /// Field 2: `end`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "end",
                with = "::buffa::json_helpers::opt_int32",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub end: ::core::option::Option<i32>,
        #[cfg_attr(feature = "json", serde(skip))]
        #[doc(hidden)]
        pub __buffa_unknown_fields: ::buffa::UnknownFields,
    }
    impl ::core::fmt::Debug for ReservedRange {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            f.debug_struct("ReservedRange")
                .field("start", &self.start)
                .field("end", &self.end)
                .finish()
        }
    }
    impl ReservedRange {
        /// Protobuf type URL for this message, for use with `Any::pack` and
        /// `Any::unpack_if`.
        ///
        /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
        pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.DescriptorProto.ReservedRange";
    }
    impl ReservedRange {
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::start`] to `Some(value)`, consuming and returning `self`.
        pub fn with_start(mut self, value: i32) -> Self {
            self.start = Some(value);
            self
        }
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::end`] to `Some(value)`, consuming and returning `self`.
        pub fn with_end(mut self, value: i32) -> Self {
            self.end = Some(value);
            self
        }
    }
    ::buffa::impl_default_instance!(ReservedRange);
    impl ::buffa::MessageName for ReservedRange {
        const PACKAGE: &'static str = "google.protobuf";
        const NAME: &'static str = "DescriptorProto.ReservedRange";
        const FULL_NAME: &'static str = "google.protobuf.DescriptorProto.ReservedRange";
        const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.DescriptorProto.ReservedRange";
    }
    impl ::buffa::Message for ReservedRange {
        /// Returns the total encoded size in bytes.
        ///
        /// Accumulates in `u64` (which cannot overflow for in-memory
        /// data) and saturates to `u32` at return, so a message whose
        /// encoded size exceeds the 2 GiB protobuf limit yields a value
        /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
        /// points reject, never a silently wrapped size.
        #[allow(clippy::let_and_return)]
        fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            let mut size = 0u64;
            if let Some(v) = self.start {
                size += 1u64 + ::buffa::types::int32_encoded_len(v) as u64;
            }
            if let Some(v) = self.end {
                size += 1u64 + ::buffa::types::int32_encoded_len(v) as u64;
            }
            size += self.__buffa_unknown_fields.encoded_len() as u64;
            ::buffa::saturate_size(size)
        }
        fn write_to(
            &self,
            _cache: &mut ::buffa::SizeCache,
            buf: &mut impl ::buffa::EncodeSink,
        ) {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if let Some(v) = self.start {
                ::buffa::types::put_int32_field(1u32, v, buf);
            }
            if let Some(v) = self.end {
                ::buffa::types::put_int32_field(2u32, v, buf);
            }
            self.__buffa_unknown_fields.write_to(buf);
        }
        fn merge_field(
            &mut self,
            tag: ::buffa::encoding::Tag,
            buf: &mut impl ::buffa::bytes::Buf,
            ctx: ::buffa::DecodeContext<'_>,
        ) -> ::core::result::Result<(), ::buffa::DecodeError> {
            #[allow(unused_imports)]
            use ::buffa::bytes::Buf as _;
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            match tag.field_number() {
                1u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::Varint,
                    )?;
                    self.start = ::core::option::Option::Some(
                        ::buffa::types::decode_int32(buf)?,
                    );
                }
                2u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::Varint,
                    )?;
                    self.end = ::core::option::Option::Some(
                        ::buffa::types::decode_int32(buf)?,
                    );
                }
                _ => {
                    self.__buffa_unknown_fields
                        .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
                }
            }
            ::core::result::Result::Ok(())
        }
        fn clear(&mut self) {
            self.start = ::core::option::Option::None;
            self.end = ::core::option::Option::None;
            self.__buffa_unknown_fields.clear();
        }
    }
    impl ::buffa::ExtensionSet for ReservedRange {
        const PROTO_FQN: &'static str = "google.protobuf.DescriptorProto.ReservedRange";
        fn unknown_fields(&self) -> &::buffa::UnknownFields {
            &self.__buffa_unknown_fields
        }
        fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
            &mut self.__buffa_unknown_fields
        }
    }
    #[cfg(feature = "text")]
    impl ::buffa::text::TextFormat for ReservedRange {
        fn encode_text(
            &self,
            enc: &mut ::buffa::text::TextEncoder<'_>,
        ) -> ::core::fmt::Result {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if let ::core::option::Option::Some(ref __v) = self.start {
                enc.write_field_name("start")?;
                enc.write_i32(*__v)?;
            }
            if let ::core::option::Option::Some(ref __v) = self.end {
                enc.write_field_name("end")?;
                enc.write_i32(*__v)?;
            }
            enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
            ::core::result::Result::Ok(())
        }
        fn merge_text(
            &mut self,
            dec: &mut ::buffa::text::TextDecoder<'_>,
        ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
                match __name {
                    "start" => self.start = ::core::option::Option::Some(dec.read_i32()?),
                    "end" => self.end = ::core::option::Option::Some(dec.read_i32()?),
                    _ => dec.skip_value()?,
                }
            }
            ::core::result::Result::Ok(())
        }
    }
    #[cfg(feature = "json")]
    impl ::buffa::json_helpers::ProtoElemJson for ReservedRange {
        fn serialize_proto_json<S: ::serde::Serializer>(
            v: &Self,
            s: S,
        ) -> ::core::result::Result<S::Ok, S::Error> {
            ::serde::Serialize::serialize(v, s)
        }
        fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
            d: D,
        ) -> ::core::result::Result<Self, D::Error> {
            <Self as ::serde::Deserialize>::deserialize(d)
        }
    }
    #[cfg(feature = "json")]
    #[doc(hidden)]
    pub const __RESERVED_RANGE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.DescriptorProto.ReservedRange",
        to_json: ::buffa::type_registry::any_to_json::<ReservedRange>,
        from_json: ::buffa::type_registry::any_from_json::<ReservedRange>,
        is_wkt: false,
    };
    #[cfg(feature = "text")]
    #[doc(hidden)]
    pub const __RESERVED_RANGE_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.DescriptorProto.ReservedRange",
        text_encode: ::buffa::type_registry::any_encode_text::<ReservedRange>,
        text_merge: ::buffa::type_registry::any_merge_text::<ReservedRange>,
    };
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::descriptor_proto::ExtensionRangeView;
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::descriptor_proto::ExtensionRangeOwnedView;
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::descriptor_proto::ReservedRangeView;
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::descriptor_proto::ReservedRangeOwnedView;
}
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct ExtensionRangeOptions {
    /// The parser stores options it doesn't recognize here. See above.
    ///
    /// Field 999: `uninterpreted_option`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "uninterpretedOption",
            alias = "uninterpreted_option",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub uninterpreted_option: ::buffa::alloc::vec::Vec<UninterpretedOption>,
    /// For external users: DO NOT USE. We are in the process of open sourcing
    /// extension declaration and executing internal cleanups before it can be
    /// used externally.
    ///
    /// Field 2: `declaration`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "declaration",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub declaration: ::buffa::alloc::vec::Vec<extension_range_options::Declaration>,
    /// Any features defined in the specific edition.
    ///
    /// Field 50: `features`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "features",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub features: ::buffa::MessageField<FeatureSet, ::buffa::Inline<FeatureSet>>,
    /// The verification state of the range.
    /// TODO: flip the default to DECLARATION once all empty ranges
    /// are marked as UNVERIFIED.
    ///
    /// Field 3: `verification`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "verification",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub verification: ::core::option::Option<extension_range_options::VerificationState>,
    #[cfg_attr(feature = "json", serde(flatten))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: __ExtensionRangeOptionsExtJson,
}
impl ::core::fmt::Debug for ExtensionRangeOptions {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ExtensionRangeOptions")
            .field("uninterpreted_option", &self.uninterpreted_option)
            .field("declaration", &self.declaration)
            .field("features", &self.features)
            .field("verification", &self.verification)
            .finish()
    }
}
impl ExtensionRangeOptions {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.ExtensionRangeOptions";
}
impl ExtensionRangeOptions {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::verification`] to `Some(value)`, consuming and returning `self`.
    pub fn with_verification(
        mut self,
        value: impl Into<extension_range_options::VerificationState>,
    ) -> Self {
        self.verification = Some(value.into());
        self
    }
}
::buffa::impl_default_instance!(ExtensionRangeOptions);
impl ::buffa::MessageName for ExtensionRangeOptions {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "ExtensionRangeOptions";
    const FULL_NAME: &'static str = "google.protobuf.ExtensionRangeOptions";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.ExtensionRangeOptions";
}
impl ::buffa::Message for ExtensionRangeOptions {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        for v in &self.declaration {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if let Some(ref v) = self.verification {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        if self.features.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.features.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 2u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.uninterpreted_option {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 2u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for v in &self.declaration {
            ::buffa::types::put_len_delimited_header(
                2u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        if let Some(ref v) = self.verification {
            ::buffa::types::put_int32_field(3u32, v.to_i32(), buf);
        }
        if self.features.is_set() {
            ::buffa::types::put_len_delimited_header(
                50u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.features.write_to(__cache, buf);
        }
        for v in &self.uninterpreted_option {
            ::buffa::types::put_len_delimited_header(
                999u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.declaration.push(elem);
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.verification = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 3u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            50u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.features.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            999u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.uninterpreted_option.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.declaration.clear();
        self.verification = ::core::option::Option::None;
        self.features = ::buffa::MessageField::none();
        self.uninterpreted_option.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ExtensionRangeOptions {
    const PROTO_FQN: &'static str = "google.protobuf.ExtensionRangeOptions";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for ExtensionRangeOptions {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.features.is_set() {
            enc.write_field_name("features")?;
            enc.write_message(&*self.features)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.verification {
            enc.write_field_name("verification")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        for __v in &self.uninterpreted_option {
            enc.write_field_name("uninterpreted_option")?;
            enc.write_message(__v)?;
        }
        for __v in &self.declaration {
            enc.write_field_name("declaration")?;
            enc.write_message(__v)?;
        }
        enc.write_extension_fields(
            "google.protobuf.ExtensionRangeOptions",
            &self.__buffa_unknown_fields,
        )?;
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "features" => dec.merge_message(self.features.get_or_insert_default())?,
                "verification" => {
                    self.verification = ::core::option::Option::Some(
                        dec
                            .read_closed_enum_by_name::<
                                extension_range_options::VerificationState,
                            >()?,
                    );
                }
                "uninterpreted_option" => {
                    dec.read_repeated_into(
                        &mut self.uninterpreted_option,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                "declaration" => {
                    dec.read_repeated_into(
                        &mut self.declaration,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                __name if __name.starts_with('[') => {
                    for __r in dec
                        .read_extension(__name, "google.protobuf.ExtensionRangeOptions")?
                    {
                        self.__buffa_unknown_fields.push(__r);
                    }
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl<'de> serde::Deserialize<'de> for ExtensionRangeOptions {
    fn deserialize<D: serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl<'de> serde::de::Visitor<'de> for _V {
            type Value = ExtensionRangeOptions;
            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                f.write_str("struct ExtensionRangeOptions")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<ExtensionRangeOptions, A::Error> {
                let mut __f_uninterpreted_option: ::core::option::Option<
                    ::buffa::alloc::vec::Vec<UninterpretedOption>,
                > = None;
                let mut __f_declaration: ::core::option::Option<
                    ::buffa::alloc::vec::Vec<extension_range_options::Declaration>,
                > = None;
                let mut __f_features: ::core::option::Option<
                    ::buffa::MessageField<FeatureSet, ::buffa::Inline<FeatureSet>>,
                > = None;
                let mut __f_verification: ::core::option::Option<
                    ::core::option::Option<extension_range_options::VerificationState>,
                > = None;
                let mut __ext_records: ::buffa::alloc::vec::Vec<::buffa::UnknownField> = ::buffa::alloc::vec::Vec::new();
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "uninterpretedOption" | "uninterpreted_option" => {
                            __f_uninterpreted_option = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::buffa::alloc::vec::Vec<UninterpretedOption>;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::buffa::alloc::vec::Vec<UninterpretedOption>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::null_as_default(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "declaration" => {
                            __f_declaration = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::buffa::alloc::vec::Vec<
                                        extension_range_options::Declaration,
                                    >;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::buffa::alloc::vec::Vec<
                                            extension_range_options::Declaration,
                                        >,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::null_as_default(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "features" => {
                            __f_features = Some(
                                map
                                    .next_value::<
                                        ::buffa::MessageField<
                                            FeatureSet,
                                            ::buffa::Inline<FeatureSet>,
                                        >,
                                    >()?,
                            );
                        }
                        "verification" => {
                            __f_verification = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::core::option::Option<
                                        extension_range_options::VerificationState,
                                    >;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::core::option::Option<
                                            extension_range_options::VerificationState,
                                        >,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::opt_closed_enum::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        __k if __k.starts_with('[') => {
                            let __v: ::buffa::serde_json::Value = map.next_value()?;
                            match ::buffa::extension_registry::deserialize_extension_key(
                                "google.protobuf.ExtensionRangeOptions",
                                __k,
                                __v,
                            ) {
                                ::core::option::Option::Some(
                                    ::core::result::Result::Ok(__recs),
                                ) => {
                                    for __rec in __recs {
                                        __ext_records.push(__rec);
                                    }
                                }
                                ::core::option::Option::Some(
                                    ::core::result::Result::Err(__e),
                                ) => {
                                    return ::core::result::Result::Err(
                                        <A::Error as ::serde::de::Error>::custom(__e),
                                    );
                                }
                                ::core::option::Option::None => {}
                            }
                        }
                        _ => {
                            map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                let mut __r = <ExtensionRangeOptions as ::core::default::Default>::default();
                if let ::core::option::Option::Some(v) = __f_uninterpreted_option {
                    __r.uninterpreted_option = v;
                }
                if let ::core::option::Option::Some(v) = __f_declaration {
                    __r.declaration = v;
                }
                if let ::core::option::Option::Some(v) = __f_features {
                    __r.features = v;
                }
                if let ::core::option::Option::Some(v) = __f_verification {
                    __r.verification = v;
                }
                for __rec in __ext_records {
                    __r.__buffa_unknown_fields.push(__rec);
                }
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for ExtensionRangeOptions {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
#[derive(Clone, Debug, Default, PartialEq)]
#[repr(transparent)]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct __ExtensionRangeOptionsExtJson(pub ::buffa::UnknownFields);
impl ::core::ops::Deref for __ExtensionRangeOptionsExtJson {
    type Target = ::buffa::UnknownFields;
    fn deref(&self) -> &::buffa::UnknownFields {
        &self.0
    }
}
impl ::core::ops::DerefMut for __ExtensionRangeOptionsExtJson {
    fn deref_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.0
    }
}
impl ::core::convert::From<::buffa::UnknownFields> for __ExtensionRangeOptionsExtJson {
    fn from(u: ::buffa::UnknownFields) -> Self {
        Self(u)
    }
}
#[cfg(feature = "json")]
impl ::serde::Serialize for __ExtensionRangeOptionsExtJson {
    fn serialize<S: ::serde::Serializer>(
        &self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::buffa::extension_registry::serialize_extensions(
            "google.protobuf.ExtensionRangeOptions",
            &self.0,
            s,
        )
    }
}
#[cfg(feature = "json")]
impl<'de> ::serde::Deserialize<'de> for __ExtensionRangeOptionsExtJson {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        ::buffa::extension_registry::deserialize_extensions(
                "google.protobuf.ExtensionRangeOptions",
                d,
            )
            .map(Self)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __EXTENSION_RANGE_OPTIONS_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.ExtensionRangeOptions",
    to_json: ::buffa::type_registry::any_to_json::<ExtensionRangeOptions>,
    from_json: ::buffa::type_registry::any_from_json::<ExtensionRangeOptions>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __EXTENSION_RANGE_OPTIONS_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.ExtensionRangeOptions",
    text_encode: ::buffa::type_registry::any_encode_text::<ExtensionRangeOptions>,
    text_merge: ::buffa::type_registry::any_merge_text::<ExtensionRangeOptions>,
};
pub mod extension_range_options {
    #[allow(unused_imports)]
    use super::*;
    /// The verification state of the extension range.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    #[repr(i32)]
    pub enum VerificationState {
        /// All the extensions of the range must be declared.
        DECLARATION = 0i32,
        UNVERIFIED = 1i32,
    }
    impl VerificationState {
        ///Idiomatic alias for [`Self::DECLARATION`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Declaration: Self = Self::DECLARATION;
        ///Idiomatic alias for [`Self::UNVERIFIED`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Unverified: Self = Self::UNVERIFIED;
    }
    impl ::core::default::Default for VerificationState {
        fn default() -> Self {
            Self::DECLARATION
        }
    }
    #[cfg(feature = "json")]
    const _: () = {
        impl ::serde::Serialize for VerificationState {
            fn serialize<S: ::serde::Serializer>(
                &self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                s.serialize_str(::buffa::Enumeration::proto_name(self))
            }
        }
        impl<'de> ::serde::Deserialize<'de> for VerificationState {
            fn deserialize<D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                struct _V;
                impl ::serde::de::Visitor<'_> for _V {
                    type Value = VerificationState;
                    fn expecting(
                        &self,
                        f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        f.write_str(
                            concat!(
                                "a string, integer, or null for ",
                                stringify!(VerificationState)
                            ),
                        )
                    }
                    fn visit_str<E: ::serde::de::Error>(
                        self,
                        v: &str,
                    ) -> ::core::result::Result<VerificationState, E> {
                        <VerificationState as ::buffa::Enumeration>::from_proto_name(v)
                            .ok_or_else(|| {
                                ::serde::de::Error::unknown_variant(v, &[])
                            })
                    }
                    fn visit_i64<E: ::serde::de::Error>(
                        self,
                        v: i64,
                    ) -> ::core::result::Result<VerificationState, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <VerificationState as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_u64<E: ::serde::de::Error>(
                        self,
                        v: u64,
                    ) -> ::core::result::Result<VerificationState, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <VerificationState as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_unit<E: ::serde::de::Error>(
                        self,
                    ) -> ::core::result::Result<VerificationState, E> {
                        ::core::result::Result::Ok(::core::default::Default::default())
                    }
                }
                d.deserialize_any(_V)
            }
        }
        impl ::buffa::json_helpers::ProtoElemJson for VerificationState {
            fn serialize_proto_json<S: ::serde::Serializer>(
                v: &Self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                ::serde::Serialize::serialize(v, s)
            }
            fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                <Self as ::serde::Deserialize>::deserialize(d)
            }
        }
    };
    impl ::buffa::Enumeration for VerificationState {
        fn from_i32(value: i32) -> ::core::option::Option<Self> {
            match value {
                0i32 => ::core::option::Option::Some(Self::DECLARATION),
                1i32 => ::core::option::Option::Some(Self::UNVERIFIED),
                _ => ::core::option::Option::None,
            }
        }
        fn to_i32(&self) -> i32 {
            *self as i32
        }
        fn proto_name(&self) -> &'static str {
            match self {
                Self::DECLARATION => "DECLARATION",
                Self::UNVERIFIED => "UNVERIFIED",
            }
        }
        fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
            match name {
                "DECLARATION" => ::core::option::Option::Some(Self::DECLARATION),
                "UNVERIFIED" => ::core::option::Option::Some(Self::UNVERIFIED),
                _ => ::core::option::Option::None,
            }
        }
        fn values() -> &'static [Self] {
            &[Self::DECLARATION, Self::UNVERIFIED]
        }
    }
    #[derive(Clone, PartialEq, Default)]
    #[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
    #[cfg_attr(feature = "json", serde(default))]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    pub struct Declaration {
        /// The extension number declared within the extension range.
        ///
        /// Field 1: `number`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "number",
                with = "::buffa::json_helpers::opt_int32",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub number: ::core::option::Option<i32>,
        /// The fully-qualified name of the extension field. There must be a leading
        /// dot in front of the full name.
        ///
        /// Field 2: `full_name`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "fullName",
                alias = "full_name",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub full_name: ::core::option::Option<::buffa::alloc::string::String>,
        /// The fully-qualified type name of the extension field. Unlike
        /// Metadata.type, Declaration.type must have a leading dot for messages
        /// and enums.
        ///
        /// Field 3: `type`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "type",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub r#type: ::core::option::Option<::buffa::alloc::string::String>,
        /// If true, indicates that the number is reserved in the extension range,
        /// and any extension field with the number will fail to compile. Set this
        /// when a declared extension field is deleted.
        ///
        /// Field 5: `reserved`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "reserved",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub reserved: ::core::option::Option<bool>,
        /// If true, indicates that the extension must be defined as repeated.
        /// Otherwise the extension must be defined as optional.
        ///
        /// Field 6: `repeated`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "repeated",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub repeated: ::core::option::Option<bool>,
        #[cfg_attr(feature = "json", serde(skip))]
        #[doc(hidden)]
        pub __buffa_unknown_fields: ::buffa::UnknownFields,
    }
    impl ::core::fmt::Debug for Declaration {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            f.debug_struct("Declaration")
                .field("number", &self.number)
                .field("full_name", &self.full_name)
                .field("type", &self.r#type)
                .field("reserved", &self.reserved)
                .field("repeated", &self.repeated)
                .finish()
        }
    }
    impl Declaration {
        /// Protobuf type URL for this message, for use with `Any::pack` and
        /// `Any::unpack_if`.
        ///
        /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
        pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.ExtensionRangeOptions.Declaration";
    }
    impl Declaration {
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::number`] to `Some(value)`, consuming and returning `self`.
        pub fn with_number(mut self, value: i32) -> Self {
            self.number = Some(value);
            self
        }
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::full_name`] to `Some(value)`, consuming and returning `self`.
        pub fn with_full_name(
            mut self,
            value: impl Into<::buffa::alloc::string::String>,
        ) -> Self {
            self.full_name = Some(value.into());
            self
        }
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets `type` to `Some(value)`, consuming and returning `self`.
        pub fn with_type(
            mut self,
            value: impl Into<::buffa::alloc::string::String>,
        ) -> Self {
            self.r#type = Some(value.into());
            self
        }
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::reserved`] to `Some(value)`, consuming and returning `self`.
        pub fn with_reserved(mut self, value: bool) -> Self {
            self.reserved = Some(value);
            self
        }
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::repeated`] to `Some(value)`, consuming and returning `self`.
        pub fn with_repeated(mut self, value: bool) -> Self {
            self.repeated = Some(value);
            self
        }
    }
    ::buffa::impl_default_instance!(Declaration);
    impl ::buffa::MessageName for Declaration {
        const PACKAGE: &'static str = "google.protobuf";
        const NAME: &'static str = "ExtensionRangeOptions.Declaration";
        const FULL_NAME: &'static str = "google.protobuf.ExtensionRangeOptions.Declaration";
        const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.ExtensionRangeOptions.Declaration";
    }
    impl ::buffa::Message for Declaration {
        /// Returns the total encoded size in bytes.
        ///
        /// Accumulates in `u64` (which cannot overflow for in-memory
        /// data) and saturates to `u32` at return, so a message whose
        /// encoded size exceeds the 2 GiB protobuf limit yields a value
        /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
        /// points reject, never a silently wrapped size.
        #[allow(clippy::let_and_return)]
        fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            let mut size = 0u64;
            if let Some(v) = self.number {
                size += 1u64 + ::buffa::types::int32_encoded_len(v) as u64;
            }
            if let Some(ref v) = self.full_name {
                size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
            }
            if let Some(ref v) = self.r#type {
                size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
            }
            if self.reserved.is_some() {
                size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
            }
            if self.repeated.is_some() {
                size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
            }
            size += self.__buffa_unknown_fields.encoded_len() as u64;
            ::buffa::saturate_size(size)
        }
        fn write_to(
            &self,
            _cache: &mut ::buffa::SizeCache,
            buf: &mut impl ::buffa::EncodeSink,
        ) {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if let Some(v) = self.number {
                ::buffa::types::put_int32_field(1u32, v, buf);
            }
            if let Some(ref v) = self.full_name {
                ::buffa::types::put_string_field(2u32, v, buf);
            }
            if let Some(ref v) = self.r#type {
                ::buffa::types::put_string_field(3u32, v, buf);
            }
            if let Some(v) = self.reserved {
                ::buffa::types::put_bool_field(5u32, v, buf);
            }
            if let Some(v) = self.repeated {
                ::buffa::types::put_bool_field(6u32, v, buf);
            }
            self.__buffa_unknown_fields.write_to(buf);
        }
        fn merge_field(
            &mut self,
            tag: ::buffa::encoding::Tag,
            buf: &mut impl ::buffa::bytes::Buf,
            ctx: ::buffa::DecodeContext<'_>,
        ) -> ::core::result::Result<(), ::buffa::DecodeError> {
            #[allow(unused_imports)]
            use ::buffa::bytes::Buf as _;
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            match tag.field_number() {
                1u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::Varint,
                    )?;
                    self.number = ::core::option::Option::Some(
                        ::buffa::types::decode_int32(buf)?,
                    );
                }
                2u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::LengthDelimited,
                    )?;
                    ::buffa::types::merge_string(
                        self
                            .full_name
                            .get_or_insert_with(::buffa::alloc::string::String::new),
                        buf,
                    )?;
                }
                3u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::LengthDelimited,
                    )?;
                    ::buffa::types::merge_string(
                        self
                            .r#type
                            .get_or_insert_with(::buffa::alloc::string::String::new),
                        buf,
                    )?;
                }
                5u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::Varint,
                    )?;
                    self.reserved = ::core::option::Option::Some(
                        ::buffa::types::decode_bool(buf)?,
                    );
                }
                6u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::Varint,
                    )?;
                    self.repeated = ::core::option::Option::Some(
                        ::buffa::types::decode_bool(buf)?,
                    );
                }
                _ => {
                    self.__buffa_unknown_fields
                        .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
                }
            }
            ::core::result::Result::Ok(())
        }
        fn clear(&mut self) {
            self.number = ::core::option::Option::None;
            self.full_name = ::core::option::Option::None;
            self.r#type = ::core::option::Option::None;
            self.reserved = ::core::option::Option::None;
            self.repeated = ::core::option::Option::None;
            self.__buffa_unknown_fields.clear();
        }
    }
    impl ::buffa::ExtensionSet for Declaration {
        const PROTO_FQN: &'static str = "google.protobuf.ExtensionRangeOptions.Declaration";
        fn unknown_fields(&self) -> &::buffa::UnknownFields {
            &self.__buffa_unknown_fields
        }
        fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
            &mut self.__buffa_unknown_fields
        }
    }
    #[cfg(feature = "text")]
    impl ::buffa::text::TextFormat for Declaration {
        fn encode_text(
            &self,
            enc: &mut ::buffa::text::TextEncoder<'_>,
        ) -> ::core::fmt::Result {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if let ::core::option::Option::Some(ref __v) = self.number {
                enc.write_field_name("number")?;
                enc.write_i32(*__v)?;
            }
            if let ::core::option::Option::Some(ref __v) = self.full_name {
                enc.write_field_name("full_name")?;
                enc.write_string(__v)?;
            }
            if let ::core::option::Option::Some(ref __v) = self.r#type {
                enc.write_field_name("type")?;
                enc.write_string(__v)?;
            }
            if let ::core::option::Option::Some(ref __v) = self.reserved {
                enc.write_field_name("reserved")?;
                enc.write_bool(*__v)?;
            }
            if let ::core::option::Option::Some(ref __v) = self.repeated {
                enc.write_field_name("repeated")?;
                enc.write_bool(*__v)?;
            }
            enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
            ::core::result::Result::Ok(())
        }
        fn merge_text(
            &mut self,
            dec: &mut ::buffa::text::TextDecoder<'_>,
        ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
                match __name {
                    "number" => {
                        self.number = ::core::option::Option::Some(dec.read_i32()?);
                    }
                    "full_name" => {
                        self.full_name = ::core::option::Option::Some(
                            dec.read_string()?.into_owned(),
                        );
                    }
                    "type" => {
                        self.r#type = ::core::option::Option::Some(
                            dec.read_string()?.into_owned(),
                        );
                    }
                    "reserved" => {
                        self.reserved = ::core::option::Option::Some(dec.read_bool()?);
                    }
                    "repeated" => {
                        self.repeated = ::core::option::Option::Some(dec.read_bool()?);
                    }
                    _ => dec.skip_value()?,
                }
            }
            ::core::result::Result::Ok(())
        }
    }
    #[cfg(feature = "json")]
    impl ::buffa::json_helpers::ProtoElemJson for Declaration {
        fn serialize_proto_json<S: ::serde::Serializer>(
            v: &Self,
            s: S,
        ) -> ::core::result::Result<S::Ok, S::Error> {
            ::serde::Serialize::serialize(v, s)
        }
        fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
            d: D,
        ) -> ::core::result::Result<Self, D::Error> {
            <Self as ::serde::Deserialize>::deserialize(d)
        }
    }
    #[cfg(feature = "json")]
    #[doc(hidden)]
    pub const __DECLARATION_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.ExtensionRangeOptions.Declaration",
        to_json: ::buffa::type_registry::any_to_json::<Declaration>,
        from_json: ::buffa::type_registry::any_from_json::<Declaration>,
        is_wkt: false,
    };
    #[cfg(feature = "text")]
    #[doc(hidden)]
    pub const __DECLARATION_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.ExtensionRangeOptions.Declaration",
        text_encode: ::buffa::type_registry::any_encode_text::<Declaration>,
        text_merge: ::buffa::type_registry::any_merge_text::<Declaration>,
    };
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::extension_range_options::DeclarationView;
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::extension_range_options::DeclarationOwnedView;
}
/// Describes a field within a message.
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct FieldDescriptorProto {
    /// Field 1: `name`
    #[cfg_attr(
        feature = "json",
        serde(rename = "name", skip_serializing_if = "::core::option::Option::is_none")
    )]
    pub name: ::core::option::Option<::buffa::alloc::string::String>,
    /// Field 3: `number`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "number",
            with = "::buffa::json_helpers::opt_int32",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub number: ::core::option::Option<i32>,
    /// Field 4: `label`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "label",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub label: ::core::option::Option<field_descriptor_proto::Label>,
    /// If type_name is set, this need not be set.  If both this and type_name
    /// are set, this must be one of TYPE_ENUM, TYPE_MESSAGE or TYPE_GROUP.
    ///
    /// Field 5: `type`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "type",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub r#type: ::core::option::Option<field_descriptor_proto::Type>,
    /// For message and enum types, this is the name of the type.  If the name
    /// starts with a '.', it is fully-qualified.  Otherwise, C++-like scoping
    /// rules are used to find the type (i.e. first the nested types within this
    /// message are searched, then within the parent, on up to the root
    /// namespace).
    ///
    /// Field 6: `type_name`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "typeName",
            alias = "type_name",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub type_name: ::core::option::Option<::buffa::alloc::string::String>,
    /// For extensions, this is the name of the type being extended.  It is
    /// resolved in the same manner as type_name.
    ///
    /// Field 2: `extendee`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "extendee",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub extendee: ::core::option::Option<::buffa::alloc::string::String>,
    /// For numeric types, contains the original text representation of the value.
    /// For booleans, "true" or "false".
    /// For strings, contains the default text contents (not escaped in any way).
    /// For bytes, contains the C escaped value.  All bytes \>= 128 are escaped.
    ///
    /// Field 7: `default_value`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "defaultValue",
            alias = "default_value",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub default_value: ::core::option::Option<::buffa::alloc::string::String>,
    /// If set, gives the index of a oneof in the containing type's oneof_decl
    /// list.  This field is a member of that oneof.
    ///
    /// Field 9: `oneof_index`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "oneofIndex",
            alias = "oneof_index",
            with = "::buffa::json_helpers::opt_int32",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub oneof_index: ::core::option::Option<i32>,
    /// JSON name of this field. The value is set by protocol compiler. If the
    /// user has set a "json_name" option on this field, that option's value
    /// will be used. Otherwise, it's deduced from the field's name by converting
    /// it to camelCase.
    ///
    /// Field 10: `json_name`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "jsonName",
            alias = "json_name",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub json_name: ::core::option::Option<::buffa::alloc::string::String>,
    /// Field 8: `options`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "options",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub options: ::buffa::MessageField<FieldOptions, ::buffa::Inline<FieldOptions>>,
    /// If true, this is a proto3 "optional". When a proto3 field is optional, it
    /// tracks presence regardless of field type.
    ///
    /// When proto3_optional is true, this field must belong to a oneof to signal
    /// to old proto3 clients that presence is tracked for this field. This oneof
    /// is known as a "synthetic" oneof, and this field must be its sole member
    /// (each proto3 optional field gets its own synthetic oneof). Synthetic oneofs
    /// exist in the descriptor only, and do not generate any API. Synthetic oneofs
    /// must be ordered after all "real" oneofs.
    ///
    /// For message fields, proto3_optional doesn't create any semantic change,
    /// since non-repeated message fields always track presence. However it still
    /// indicates the semantic detail of whether the user wrote "optional" or not.
    /// This can be useful for round-tripping the .proto file. For consistency we
    /// give message fields a synthetic oneof also, even though it is not required
    /// to track presence. This is especially important because the parser can't
    /// tell if a field is a message or an enum, so it must always create a
    /// synthetic oneof.
    ///
    /// Proto2 optional fields do not set this flag, because they already indicate
    /// optional with `LABEL_OPTIONAL`.
    ///
    /// Field 17: `proto3_optional`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "proto3Optional",
            alias = "proto3_optional",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub proto3_optional: ::core::option::Option<bool>,
    #[cfg_attr(feature = "json", serde(skip))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for FieldDescriptorProto {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("FieldDescriptorProto")
            .field("name", &self.name)
            .field("number", &self.number)
            .field("label", &self.label)
            .field("type", &self.r#type)
            .field("type_name", &self.type_name)
            .field("extendee", &self.extendee)
            .field("default_value", &self.default_value)
            .field("oneof_index", &self.oneof_index)
            .field("json_name", &self.json_name)
            .field("options", &self.options)
            .field("proto3_optional", &self.proto3_optional)
            .finish()
    }
}
impl FieldDescriptorProto {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FieldDescriptorProto";
}
impl FieldDescriptorProto {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::name`] to `Some(value)`, consuming and returning `self`.
    pub fn with_name(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.name = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::number`] to `Some(value)`, consuming and returning `self`.
    pub fn with_number(mut self, value: i32) -> Self {
        self.number = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::label`] to `Some(value)`, consuming and returning `self`.
    pub fn with_label(
        mut self,
        value: impl Into<field_descriptor_proto::Label>,
    ) -> Self {
        self.label = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets `type` to `Some(value)`, consuming and returning `self`.
    pub fn with_type(mut self, value: impl Into<field_descriptor_proto::Type>) -> Self {
        self.r#type = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::type_name`] to `Some(value)`, consuming and returning `self`.
    pub fn with_type_name(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.type_name = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::extendee`] to `Some(value)`, consuming and returning `self`.
    pub fn with_extendee(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.extendee = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::default_value`] to `Some(value)`, consuming and returning `self`.
    pub fn with_default_value(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.default_value = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::oneof_index`] to `Some(value)`, consuming and returning `self`.
    pub fn with_oneof_index(mut self, value: i32) -> Self {
        self.oneof_index = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::json_name`] to `Some(value)`, consuming and returning `self`.
    pub fn with_json_name(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.json_name = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::proto3_optional`] to `Some(value)`, consuming and returning `self`.
    pub fn with_proto3_optional(mut self, value: bool) -> Self {
        self.proto3_optional = Some(value);
        self
    }
}
::buffa::impl_default_instance!(FieldDescriptorProto);
impl ::buffa::MessageName for FieldDescriptorProto {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "FieldDescriptorProto";
    const FULL_NAME: &'static str = "google.protobuf.FieldDescriptorProto";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FieldDescriptorProto";
}
impl ::buffa::Message for FieldDescriptorProto {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if let Some(ref v) = self.name {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.extendee {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(v) = self.number {
            size += 1u64 + ::buffa::types::int32_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.label {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        if let Some(ref v) = self.r#type {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        if let Some(ref v) = self.type_name {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.default_value {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if self.options.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.options.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if let Some(v) = self.oneof_index {
            size += 1u64 + ::buffa::types::int32_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.json_name {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if self.proto3_optional.is_some() {
            size += 2u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let Some(ref v) = self.name {
            ::buffa::types::put_string_field(1u32, v, buf);
        }
        if let Some(ref v) = self.extendee {
            ::buffa::types::put_string_field(2u32, v, buf);
        }
        if let Some(v) = self.number {
            ::buffa::types::put_int32_field(3u32, v, buf);
        }
        if let Some(ref v) = self.label {
            ::buffa::types::put_int32_field(4u32, v.to_i32(), buf);
        }
        if let Some(ref v) = self.r#type {
            ::buffa::types::put_int32_field(5u32, v.to_i32(), buf);
        }
        if let Some(ref v) = self.type_name {
            ::buffa::types::put_string_field(6u32, v, buf);
        }
        if let Some(ref v) = self.default_value {
            ::buffa::types::put_string_field(7u32, v, buf);
        }
        if self.options.is_set() {
            ::buffa::types::put_len_delimited_header(
                8u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.options.write_to(__cache, buf);
        }
        if let Some(v) = self.oneof_index {
            ::buffa::types::put_int32_field(9u32, v, buf);
        }
        if let Some(ref v) = self.json_name {
            ::buffa::types::put_string_field(10u32, v, buf);
        }
        if let Some(v) = self.proto3_optional {
            ::buffa::types::put_bool_field(17u32, v, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self.name.get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self
                        .extendee
                        .get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.number = ::core::option::Option::Some(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.label = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 4u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.r#type = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 5u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self
                        .type_name
                        .get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self
                        .default_value
                        .get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.options.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            9u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.oneof_index = ::core::option::Option::Some(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            10u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self
                        .json_name
                        .get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            17u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.proto3_optional = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.name = ::core::option::Option::None;
        self.extendee = ::core::option::Option::None;
        self.number = ::core::option::Option::None;
        self.label = ::core::option::Option::None;
        self.r#type = ::core::option::Option::None;
        self.type_name = ::core::option::Option::None;
        self.default_value = ::core::option::Option::None;
        self.options = ::buffa::MessageField::none();
        self.oneof_index = ::core::option::Option::None;
        self.json_name = ::core::option::Option::None;
        self.proto3_optional = ::core::option::Option::None;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for FieldDescriptorProto {
    const PROTO_FQN: &'static str = "google.protobuf.FieldDescriptorProto";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for FieldDescriptorProto {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref __v) = self.name {
            enc.write_field_name("name")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.number {
            enc.write_field_name("number")?;
            enc.write_i32(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.label {
            enc.write_field_name("label")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        if let ::core::option::Option::Some(ref __v) = self.r#type {
            enc.write_field_name("type")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        if let ::core::option::Option::Some(ref __v) = self.type_name {
            enc.write_field_name("type_name")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.extendee {
            enc.write_field_name("extendee")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.default_value {
            enc.write_field_name("default_value")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.oneof_index {
            enc.write_field_name("oneof_index")?;
            enc.write_i32(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.json_name {
            enc.write_field_name("json_name")?;
            enc.write_string(__v)?;
        }
        if self.options.is_set() {
            enc.write_field_name("options")?;
            enc.write_message(&*self.options)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.proto3_optional {
            enc.write_field_name("proto3_optional")?;
            enc.write_bool(*__v)?;
        }
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "name" => {
                    self.name = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "number" => self.number = ::core::option::Option::Some(dec.read_i32()?),
                "label" => {
                    self.label = ::core::option::Option::Some(
                        dec.read_closed_enum_by_name::<field_descriptor_proto::Label>()?,
                    );
                }
                "type" => {
                    self.r#type = ::core::option::Option::Some(
                        dec.read_closed_enum_by_name::<field_descriptor_proto::Type>()?,
                    );
                }
                "type_name" => {
                    self.type_name = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "extendee" => {
                    self.extendee = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "default_value" => {
                    self.default_value = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "oneof_index" => {
                    self.oneof_index = ::core::option::Option::Some(dec.read_i32()?);
                }
                "json_name" => {
                    self.json_name = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "options" => dec.merge_message(self.options.get_or_insert_default())?,
                "proto3_optional" => {
                    self.proto3_optional = ::core::option::Option::Some(dec.read_bool()?);
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for FieldDescriptorProto {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __FIELD_DESCRIPTOR_PROTO_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.FieldDescriptorProto",
    to_json: ::buffa::type_registry::any_to_json::<FieldDescriptorProto>,
    from_json: ::buffa::type_registry::any_from_json::<FieldDescriptorProto>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __FIELD_DESCRIPTOR_PROTO_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.FieldDescriptorProto",
    text_encode: ::buffa::type_registry::any_encode_text::<FieldDescriptorProto>,
    text_merge: ::buffa::type_registry::any_merge_text::<FieldDescriptorProto>,
};
pub mod field_descriptor_proto {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    #[repr(i32)]
    pub enum Type {
        /// 0 is reserved for errors.
        /// Order is weird for historical reasons.
        TYPE_DOUBLE = 1i32,
        TYPE_FLOAT = 2i32,
        /// Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
        /// negative values are likely.
        TYPE_INT64 = 3i32,
        TYPE_UINT64 = 4i32,
        /// Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
        /// negative values are likely.
        TYPE_INT32 = 5i32,
        TYPE_FIXED64 = 6i32,
        TYPE_FIXED32 = 7i32,
        TYPE_BOOL = 8i32,
        TYPE_STRING = 9i32,
        /// Tag-delimited aggregate.
        /// Group type is deprecated and not supported after google.protobuf. However, Proto3
        /// implementations should still be able to parse the group wire format and
        /// treat group fields as unknown fields.  In Editions, the group wire format
        /// can be enabled via the `message_encoding` feature.
        TYPE_GROUP = 10i32,
        /// Length-delimited aggregate.
        TYPE_MESSAGE = 11i32,
        /// New in version 2.
        TYPE_BYTES = 12i32,
        TYPE_UINT32 = 13i32,
        TYPE_ENUM = 14i32,
        TYPE_SFIXED32 = 15i32,
        TYPE_SFIXED64 = 16i32,
        /// Uses ZigZag encoding.
        TYPE_SINT32 = 17i32,
        /// Uses ZigZag encoding.
        TYPE_SINT64 = 18i32,
    }
    impl Type {
        ///Idiomatic alias for [`Self::TYPE_DOUBLE`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Double: Self = Self::TYPE_DOUBLE;
        ///Idiomatic alias for [`Self::TYPE_FLOAT`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Float: Self = Self::TYPE_FLOAT;
        ///Idiomatic alias for [`Self::TYPE_INT64`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Int64: Self = Self::TYPE_INT64;
        ///Idiomatic alias for [`Self::TYPE_UINT64`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Uint64: Self = Self::TYPE_UINT64;
        ///Idiomatic alias for [`Self::TYPE_INT32`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Int32: Self = Self::TYPE_INT32;
        ///Idiomatic alias for [`Self::TYPE_FIXED64`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Fixed64: Self = Self::TYPE_FIXED64;
        ///Idiomatic alias for [`Self::TYPE_FIXED32`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Fixed32: Self = Self::TYPE_FIXED32;
        ///Idiomatic alias for [`Self::TYPE_BOOL`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Bool: Self = Self::TYPE_BOOL;
        ///Idiomatic alias for [`Self::TYPE_STRING`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const String: Self = Self::TYPE_STRING;
        ///Idiomatic alias for [`Self::TYPE_GROUP`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Group: Self = Self::TYPE_GROUP;
        ///Idiomatic alias for [`Self::TYPE_MESSAGE`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Message: Self = Self::TYPE_MESSAGE;
        ///Idiomatic alias for [`Self::TYPE_BYTES`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Bytes: Self = Self::TYPE_BYTES;
        ///Idiomatic alias for [`Self::TYPE_UINT32`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Uint32: Self = Self::TYPE_UINT32;
        ///Idiomatic alias for [`Self::TYPE_ENUM`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Enum: Self = Self::TYPE_ENUM;
        ///Idiomatic alias for [`Self::TYPE_SFIXED32`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Sfixed32: Self = Self::TYPE_SFIXED32;
        ///Idiomatic alias for [`Self::TYPE_SFIXED64`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Sfixed64: Self = Self::TYPE_SFIXED64;
        ///Idiomatic alias for [`Self::TYPE_SINT32`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Sint32: Self = Self::TYPE_SINT32;
        ///Idiomatic alias for [`Self::TYPE_SINT64`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Sint64: Self = Self::TYPE_SINT64;
    }
    impl ::core::default::Default for Type {
        fn default() -> Self {
            Self::TYPE_DOUBLE
        }
    }
    #[cfg(feature = "json")]
    const _: () = {
        impl ::serde::Serialize for Type {
            fn serialize<S: ::serde::Serializer>(
                &self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                s.serialize_str(::buffa::Enumeration::proto_name(self))
            }
        }
        impl<'de> ::serde::Deserialize<'de> for Type {
            fn deserialize<D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                struct _V;
                impl ::serde::de::Visitor<'_> for _V {
                    type Value = Type;
                    fn expecting(
                        &self,
                        f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        f.write_str(
                            concat!("a string, integer, or null for ", stringify!(Type)),
                        )
                    }
                    fn visit_str<E: ::serde::de::Error>(
                        self,
                        v: &str,
                    ) -> ::core::result::Result<Type, E> {
                        <Type as ::buffa::Enumeration>::from_proto_name(v)
                            .ok_or_else(|| {
                                ::serde::de::Error::unknown_variant(v, &[])
                            })
                    }
                    fn visit_i64<E: ::serde::de::Error>(
                        self,
                        v: i64,
                    ) -> ::core::result::Result<Type, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <Type as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_u64<E: ::serde::de::Error>(
                        self,
                        v: u64,
                    ) -> ::core::result::Result<Type, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <Type as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_unit<E: ::serde::de::Error>(
                        self,
                    ) -> ::core::result::Result<Type, E> {
                        ::core::result::Result::Ok(::core::default::Default::default())
                    }
                }
                d.deserialize_any(_V)
            }
        }
        impl ::buffa::json_helpers::ProtoElemJson for Type {
            fn serialize_proto_json<S: ::serde::Serializer>(
                v: &Self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                ::serde::Serialize::serialize(v, s)
            }
            fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                <Self as ::serde::Deserialize>::deserialize(d)
            }
        }
    };
    impl ::buffa::Enumeration for Type {
        fn from_i32(value: i32) -> ::core::option::Option<Self> {
            match value {
                1i32 => ::core::option::Option::Some(Self::TYPE_DOUBLE),
                2i32 => ::core::option::Option::Some(Self::TYPE_FLOAT),
                3i32 => ::core::option::Option::Some(Self::TYPE_INT64),
                4i32 => ::core::option::Option::Some(Self::TYPE_UINT64),
                5i32 => ::core::option::Option::Some(Self::TYPE_INT32),
                6i32 => ::core::option::Option::Some(Self::TYPE_FIXED64),
                7i32 => ::core::option::Option::Some(Self::TYPE_FIXED32),
                8i32 => ::core::option::Option::Some(Self::TYPE_BOOL),
                9i32 => ::core::option::Option::Some(Self::TYPE_STRING),
                10i32 => ::core::option::Option::Some(Self::TYPE_GROUP),
                11i32 => ::core::option::Option::Some(Self::TYPE_MESSAGE),
                12i32 => ::core::option::Option::Some(Self::TYPE_BYTES),
                13i32 => ::core::option::Option::Some(Self::TYPE_UINT32),
                14i32 => ::core::option::Option::Some(Self::TYPE_ENUM),
                15i32 => ::core::option::Option::Some(Self::TYPE_SFIXED32),
                16i32 => ::core::option::Option::Some(Self::TYPE_SFIXED64),
                17i32 => ::core::option::Option::Some(Self::TYPE_SINT32),
                18i32 => ::core::option::Option::Some(Self::TYPE_SINT64),
                _ => ::core::option::Option::None,
            }
        }
        fn to_i32(&self) -> i32 {
            *self as i32
        }
        fn proto_name(&self) -> &'static str {
            match self {
                Self::TYPE_DOUBLE => "TYPE_DOUBLE",
                Self::TYPE_FLOAT => "TYPE_FLOAT",
                Self::TYPE_INT64 => "TYPE_INT64",
                Self::TYPE_UINT64 => "TYPE_UINT64",
                Self::TYPE_INT32 => "TYPE_INT32",
                Self::TYPE_FIXED64 => "TYPE_FIXED64",
                Self::TYPE_FIXED32 => "TYPE_FIXED32",
                Self::TYPE_BOOL => "TYPE_BOOL",
                Self::TYPE_STRING => "TYPE_STRING",
                Self::TYPE_GROUP => "TYPE_GROUP",
                Self::TYPE_MESSAGE => "TYPE_MESSAGE",
                Self::TYPE_BYTES => "TYPE_BYTES",
                Self::TYPE_UINT32 => "TYPE_UINT32",
                Self::TYPE_ENUM => "TYPE_ENUM",
                Self::TYPE_SFIXED32 => "TYPE_SFIXED32",
                Self::TYPE_SFIXED64 => "TYPE_SFIXED64",
                Self::TYPE_SINT32 => "TYPE_SINT32",
                Self::TYPE_SINT64 => "TYPE_SINT64",
            }
        }
        fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
            match name {
                "TYPE_DOUBLE" => ::core::option::Option::Some(Self::TYPE_DOUBLE),
                "TYPE_FLOAT" => ::core::option::Option::Some(Self::TYPE_FLOAT),
                "TYPE_INT64" => ::core::option::Option::Some(Self::TYPE_INT64),
                "TYPE_UINT64" => ::core::option::Option::Some(Self::TYPE_UINT64),
                "TYPE_INT32" => ::core::option::Option::Some(Self::TYPE_INT32),
                "TYPE_FIXED64" => ::core::option::Option::Some(Self::TYPE_FIXED64),
                "TYPE_FIXED32" => ::core::option::Option::Some(Self::TYPE_FIXED32),
                "TYPE_BOOL" => ::core::option::Option::Some(Self::TYPE_BOOL),
                "TYPE_STRING" => ::core::option::Option::Some(Self::TYPE_STRING),
                "TYPE_GROUP" => ::core::option::Option::Some(Self::TYPE_GROUP),
                "TYPE_MESSAGE" => ::core::option::Option::Some(Self::TYPE_MESSAGE),
                "TYPE_BYTES" => ::core::option::Option::Some(Self::TYPE_BYTES),
                "TYPE_UINT32" => ::core::option::Option::Some(Self::TYPE_UINT32),
                "TYPE_ENUM" => ::core::option::Option::Some(Self::TYPE_ENUM),
                "TYPE_SFIXED32" => ::core::option::Option::Some(Self::TYPE_SFIXED32),
                "TYPE_SFIXED64" => ::core::option::Option::Some(Self::TYPE_SFIXED64),
                "TYPE_SINT32" => ::core::option::Option::Some(Self::TYPE_SINT32),
                "TYPE_SINT64" => ::core::option::Option::Some(Self::TYPE_SINT64),
                _ => ::core::option::Option::None,
            }
        }
        fn values() -> &'static [Self] {
            &[
                Self::TYPE_DOUBLE,
                Self::TYPE_FLOAT,
                Self::TYPE_INT64,
                Self::TYPE_UINT64,
                Self::TYPE_INT32,
                Self::TYPE_FIXED64,
                Self::TYPE_FIXED32,
                Self::TYPE_BOOL,
                Self::TYPE_STRING,
                Self::TYPE_GROUP,
                Self::TYPE_MESSAGE,
                Self::TYPE_BYTES,
                Self::TYPE_UINT32,
                Self::TYPE_ENUM,
                Self::TYPE_SFIXED32,
                Self::TYPE_SFIXED64,
                Self::TYPE_SINT32,
                Self::TYPE_SINT64,
            ]
        }
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    #[repr(i32)]
    pub enum Label {
        /// 0 is reserved for errors
        LABEL_OPTIONAL = 1i32,
        LABEL_REPEATED = 3i32,
        /// The required label is only allowed in google.protobuf.  In proto3 and Editions
        /// it's explicitly prohibited.  In Editions, the `field_presence` feature
        /// can be used to get this behavior.
        LABEL_REQUIRED = 2i32,
    }
    impl Label {
        ///Idiomatic alias for [`Self::LABEL_OPTIONAL`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Optional: Self = Self::LABEL_OPTIONAL;
        ///Idiomatic alias for [`Self::LABEL_REPEATED`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Repeated: Self = Self::LABEL_REPEATED;
        ///Idiomatic alias for [`Self::LABEL_REQUIRED`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Required: Self = Self::LABEL_REQUIRED;
    }
    impl ::core::default::Default for Label {
        fn default() -> Self {
            Self::LABEL_OPTIONAL
        }
    }
    #[cfg(feature = "json")]
    const _: () = {
        impl ::serde::Serialize for Label {
            fn serialize<S: ::serde::Serializer>(
                &self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                s.serialize_str(::buffa::Enumeration::proto_name(self))
            }
        }
        impl<'de> ::serde::Deserialize<'de> for Label {
            fn deserialize<D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                struct _V;
                impl ::serde::de::Visitor<'_> for _V {
                    type Value = Label;
                    fn expecting(
                        &self,
                        f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        f.write_str(
                            concat!("a string, integer, or null for ", stringify!(Label)),
                        )
                    }
                    fn visit_str<E: ::serde::de::Error>(
                        self,
                        v: &str,
                    ) -> ::core::result::Result<Label, E> {
                        <Label as ::buffa::Enumeration>::from_proto_name(v)
                            .ok_or_else(|| {
                                ::serde::de::Error::unknown_variant(v, &[])
                            })
                    }
                    fn visit_i64<E: ::serde::de::Error>(
                        self,
                        v: i64,
                    ) -> ::core::result::Result<Label, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <Label as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_u64<E: ::serde::de::Error>(
                        self,
                        v: u64,
                    ) -> ::core::result::Result<Label, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <Label as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_unit<E: ::serde::de::Error>(
                        self,
                    ) -> ::core::result::Result<Label, E> {
                        ::core::result::Result::Ok(::core::default::Default::default())
                    }
                }
                d.deserialize_any(_V)
            }
        }
        impl ::buffa::json_helpers::ProtoElemJson for Label {
            fn serialize_proto_json<S: ::serde::Serializer>(
                v: &Self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                ::serde::Serialize::serialize(v, s)
            }
            fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                <Self as ::serde::Deserialize>::deserialize(d)
            }
        }
    };
    impl ::buffa::Enumeration for Label {
        fn from_i32(value: i32) -> ::core::option::Option<Self> {
            match value {
                1i32 => ::core::option::Option::Some(Self::LABEL_OPTIONAL),
                3i32 => ::core::option::Option::Some(Self::LABEL_REPEATED),
                2i32 => ::core::option::Option::Some(Self::LABEL_REQUIRED),
                _ => ::core::option::Option::None,
            }
        }
        fn to_i32(&self) -> i32 {
            *self as i32
        }
        fn proto_name(&self) -> &'static str {
            match self {
                Self::LABEL_OPTIONAL => "LABEL_OPTIONAL",
                Self::LABEL_REPEATED => "LABEL_REPEATED",
                Self::LABEL_REQUIRED => "LABEL_REQUIRED",
            }
        }
        fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
            match name {
                "LABEL_OPTIONAL" => ::core::option::Option::Some(Self::LABEL_OPTIONAL),
                "LABEL_REPEATED" => ::core::option::Option::Some(Self::LABEL_REPEATED),
                "LABEL_REQUIRED" => ::core::option::Option::Some(Self::LABEL_REQUIRED),
                _ => ::core::option::Option::None,
            }
        }
        fn values() -> &'static [Self] {
            &[Self::LABEL_OPTIONAL, Self::LABEL_REPEATED, Self::LABEL_REQUIRED]
        }
    }
}
/// Describes a oneof.
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct OneofDescriptorProto {
    /// Field 1: `name`
    #[cfg_attr(
        feature = "json",
        serde(rename = "name", skip_serializing_if = "::core::option::Option::is_none")
    )]
    pub name: ::core::option::Option<::buffa::alloc::string::String>,
    /// Field 2: `options`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "options",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub options: ::buffa::MessageField<OneofOptions, ::buffa::Inline<OneofOptions>>,
    #[cfg_attr(feature = "json", serde(skip))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for OneofDescriptorProto {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("OneofDescriptorProto")
            .field("name", &self.name)
            .field("options", &self.options)
            .finish()
    }
}
impl OneofDescriptorProto {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.OneofDescriptorProto";
}
impl OneofDescriptorProto {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::name`] to `Some(value)`, consuming and returning `self`.
    pub fn with_name(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.name = Some(value.into());
        self
    }
}
::buffa::impl_default_instance!(OneofDescriptorProto);
impl ::buffa::MessageName for OneofDescriptorProto {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "OneofDescriptorProto";
    const FULL_NAME: &'static str = "google.protobuf.OneofDescriptorProto";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.OneofDescriptorProto";
}
impl ::buffa::Message for OneofDescriptorProto {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if let Some(ref v) = self.name {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if self.options.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.options.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let Some(ref v) = self.name {
            ::buffa::types::put_string_field(1u32, v, buf);
        }
        if self.options.is_set() {
            ::buffa::types::put_len_delimited_header(
                2u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.options.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self.name.get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.options.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.name = ::core::option::Option::None;
        self.options = ::buffa::MessageField::none();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for OneofDescriptorProto {
    const PROTO_FQN: &'static str = "google.protobuf.OneofDescriptorProto";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for OneofDescriptorProto {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref __v) = self.name {
            enc.write_field_name("name")?;
            enc.write_string(__v)?;
        }
        if self.options.is_set() {
            enc.write_field_name("options")?;
            enc.write_message(&*self.options)?;
        }
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "name" => {
                    self.name = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "options" => dec.merge_message(self.options.get_or_insert_default())?,
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for OneofDescriptorProto {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __ONEOF_DESCRIPTOR_PROTO_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.OneofDescriptorProto",
    to_json: ::buffa::type_registry::any_to_json::<OneofDescriptorProto>,
    from_json: ::buffa::type_registry::any_from_json::<OneofDescriptorProto>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __ONEOF_DESCRIPTOR_PROTO_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.OneofDescriptorProto",
    text_encode: ::buffa::type_registry::any_encode_text::<OneofDescriptorProto>,
    text_merge: ::buffa::type_registry::any_merge_text::<OneofDescriptorProto>,
};
/// Describes an enum type.
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct EnumDescriptorProto {
    /// Field 1: `name`
    #[cfg_attr(
        feature = "json",
        serde(rename = "name", skip_serializing_if = "::core::option::Option::is_none")
    )]
    pub name: ::core::option::Option<::buffa::alloc::string::String>,
    /// Field 2: `value`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "value",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub value: ::buffa::alloc::vec::Vec<EnumValueDescriptorProto>,
    /// Field 3: `options`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "options",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub options: ::buffa::MessageField<EnumOptions, ::buffa::Inline<EnumOptions>>,
    /// Range of reserved numeric values. Reserved numeric values may not be used
    /// by enum values in the same enum declaration. Reserved ranges may not
    /// overlap.
    ///
    /// Field 4: `reserved_range`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "reservedRange",
            alias = "reserved_range",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub reserved_range: ::buffa::alloc::vec::Vec<
        enum_descriptor_proto::EnumReservedRange,
    >,
    /// Reserved enum value names, which may not be reused. A given name may only
    /// be reserved once.
    ///
    /// Field 5: `reserved_name`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "reservedName",
            alias = "reserved_name",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub reserved_name: ::buffa::alloc::vec::Vec<::buffa::alloc::string::String>,
    /// Support for `export` and `local` keywords on enums.
    ///
    /// Field 6: `visibility`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "visibility",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub visibility: ::core::option::Option<SymbolVisibility>,
    #[cfg_attr(feature = "json", serde(skip))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for EnumDescriptorProto {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("EnumDescriptorProto")
            .field("name", &self.name)
            .field("value", &self.value)
            .field("options", &self.options)
            .field("reserved_range", &self.reserved_range)
            .field("reserved_name", &self.reserved_name)
            .field("visibility", &self.visibility)
            .finish()
    }
}
impl EnumDescriptorProto {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.EnumDescriptorProto";
}
impl EnumDescriptorProto {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::name`] to `Some(value)`, consuming and returning `self`.
    pub fn with_name(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.name = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::visibility`] to `Some(value)`, consuming and returning `self`.
    pub fn with_visibility(mut self, value: impl Into<SymbolVisibility>) -> Self {
        self.visibility = Some(value.into());
        self
    }
}
::buffa::impl_default_instance!(EnumDescriptorProto);
impl ::buffa::MessageName for EnumDescriptorProto {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "EnumDescriptorProto";
    const FULL_NAME: &'static str = "google.protobuf.EnumDescriptorProto";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.EnumDescriptorProto";
}
impl ::buffa::Message for EnumDescriptorProto {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if let Some(ref v) = self.name {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        for v in &self.value {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if self.options.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.options.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.reserved_range {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.reserved_name {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.visibility {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let Some(ref v) = self.name {
            ::buffa::types::put_string_field(1u32, v, buf);
        }
        for v in &self.value {
            ::buffa::types::put_len_delimited_header(
                2u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        if self.options.is_set() {
            ::buffa::types::put_len_delimited_header(
                3u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.options.write_to(__cache, buf);
        }
        for v in &self.reserved_range {
            ::buffa::types::put_len_delimited_header(
                4u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        for v in &self.reserved_name {
            ::buffa::types::put_string_field(5u32, v, buf);
        }
        if let Some(ref v) = self.visibility {
            ::buffa::types::put_int32_field(6u32, v.to_i32(), buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self.name.get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.value.push(elem);
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.options.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.reserved_range.push(elem);
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __elem = ::buffa::types::decode_string(buf)?;
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&__elem),
                )?;
                self.reserved_name.push(__elem);
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.visibility = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 6u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.name = ::core::option::Option::None;
        self.value.clear();
        self.options = ::buffa::MessageField::none();
        self.reserved_range.clear();
        self.reserved_name.clear();
        self.visibility = ::core::option::Option::None;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for EnumDescriptorProto {
    const PROTO_FQN: &'static str = "google.protobuf.EnumDescriptorProto";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for EnumDescriptorProto {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref __v) = self.name {
            enc.write_field_name("name")?;
            enc.write_string(__v)?;
        }
        if self.options.is_set() {
            enc.write_field_name("options")?;
            enc.write_message(&*self.options)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.visibility {
            enc.write_field_name("visibility")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        for __v in &self.value {
            enc.write_field_name("value")?;
            enc.write_message(__v)?;
        }
        for __v in &self.reserved_range {
            enc.write_field_name("reserved_range")?;
            enc.write_message(__v)?;
        }
        for __v in &self.reserved_name {
            enc.write_field_name("reserved_name")?;
            enc.write_string(__v)?;
        }
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "name" => {
                    self.name = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "options" => dec.merge_message(self.options.get_or_insert_default())?,
                "visibility" => {
                    self.visibility = ::core::option::Option::Some(
                        dec.read_closed_enum_by_name::<SymbolVisibility>()?,
                    );
                }
                "value" => {
                    dec.read_repeated_into(
                        &mut self.value,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                "reserved_range" => {
                    dec.read_repeated_into(
                        &mut self.reserved_range,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                "reserved_name" => {
                    dec.read_repeated_into(
                        &mut self.reserved_name,
                        |__d| ::core::result::Result::Ok(__d.read_string()?.into_owned()),
                    )?
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for EnumDescriptorProto {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __ENUM_DESCRIPTOR_PROTO_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.EnumDescriptorProto",
    to_json: ::buffa::type_registry::any_to_json::<EnumDescriptorProto>,
    from_json: ::buffa::type_registry::any_from_json::<EnumDescriptorProto>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __ENUM_DESCRIPTOR_PROTO_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.EnumDescriptorProto",
    text_encode: ::buffa::type_registry::any_encode_text::<EnumDescriptorProto>,
    text_merge: ::buffa::type_registry::any_merge_text::<EnumDescriptorProto>,
};
pub mod enum_descriptor_proto {
    #[allow(unused_imports)]
    use super::*;
    /// Range of reserved numeric values. Reserved values may not be used by
    /// entries in the same enum. Reserved ranges may not overlap.
    ///
    /// Note that this is distinct from DescriptorProto.ReservedRange in that it
    /// is inclusive such that it can appropriately represent the entire int32
    /// domain.
    #[derive(Clone, PartialEq, Default)]
    #[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
    #[cfg_attr(feature = "json", serde(default))]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    pub struct EnumReservedRange {
        /// Inclusive.
        ///
        /// Field 1: `start`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "start",
                with = "::buffa::json_helpers::opt_int32",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub start: ::core::option::Option<i32>,
        /// Inclusive.
        ///
        /// Field 2: `end`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "end",
                with = "::buffa::json_helpers::opt_int32",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub end: ::core::option::Option<i32>,
        #[cfg_attr(feature = "json", serde(skip))]
        #[doc(hidden)]
        pub __buffa_unknown_fields: ::buffa::UnknownFields,
    }
    impl ::core::fmt::Debug for EnumReservedRange {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            f.debug_struct("EnumReservedRange")
                .field("start", &self.start)
                .field("end", &self.end)
                .finish()
        }
    }
    impl EnumReservedRange {
        /// Protobuf type URL for this message, for use with `Any::pack` and
        /// `Any::unpack_if`.
        ///
        /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
        pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.EnumDescriptorProto.EnumReservedRange";
    }
    impl EnumReservedRange {
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::start`] to `Some(value)`, consuming and returning `self`.
        pub fn with_start(mut self, value: i32) -> Self {
            self.start = Some(value);
            self
        }
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::end`] to `Some(value)`, consuming and returning `self`.
        pub fn with_end(mut self, value: i32) -> Self {
            self.end = Some(value);
            self
        }
    }
    ::buffa::impl_default_instance!(EnumReservedRange);
    impl ::buffa::MessageName for EnumReservedRange {
        const PACKAGE: &'static str = "google.protobuf";
        const NAME: &'static str = "EnumDescriptorProto.EnumReservedRange";
        const FULL_NAME: &'static str = "google.protobuf.EnumDescriptorProto.EnumReservedRange";
        const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.EnumDescriptorProto.EnumReservedRange";
    }
    impl ::buffa::Message for EnumReservedRange {
        /// Returns the total encoded size in bytes.
        ///
        /// Accumulates in `u64` (which cannot overflow for in-memory
        /// data) and saturates to `u32` at return, so a message whose
        /// encoded size exceeds the 2 GiB protobuf limit yields a value
        /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
        /// points reject, never a silently wrapped size.
        #[allow(clippy::let_and_return)]
        fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            let mut size = 0u64;
            if let Some(v) = self.start {
                size += 1u64 + ::buffa::types::int32_encoded_len(v) as u64;
            }
            if let Some(v) = self.end {
                size += 1u64 + ::buffa::types::int32_encoded_len(v) as u64;
            }
            size += self.__buffa_unknown_fields.encoded_len() as u64;
            ::buffa::saturate_size(size)
        }
        fn write_to(
            &self,
            _cache: &mut ::buffa::SizeCache,
            buf: &mut impl ::buffa::EncodeSink,
        ) {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if let Some(v) = self.start {
                ::buffa::types::put_int32_field(1u32, v, buf);
            }
            if let Some(v) = self.end {
                ::buffa::types::put_int32_field(2u32, v, buf);
            }
            self.__buffa_unknown_fields.write_to(buf);
        }
        fn merge_field(
            &mut self,
            tag: ::buffa::encoding::Tag,
            buf: &mut impl ::buffa::bytes::Buf,
            ctx: ::buffa::DecodeContext<'_>,
        ) -> ::core::result::Result<(), ::buffa::DecodeError> {
            #[allow(unused_imports)]
            use ::buffa::bytes::Buf as _;
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            match tag.field_number() {
                1u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::Varint,
                    )?;
                    self.start = ::core::option::Option::Some(
                        ::buffa::types::decode_int32(buf)?,
                    );
                }
                2u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::Varint,
                    )?;
                    self.end = ::core::option::Option::Some(
                        ::buffa::types::decode_int32(buf)?,
                    );
                }
                _ => {
                    self.__buffa_unknown_fields
                        .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
                }
            }
            ::core::result::Result::Ok(())
        }
        fn clear(&mut self) {
            self.start = ::core::option::Option::None;
            self.end = ::core::option::Option::None;
            self.__buffa_unknown_fields.clear();
        }
    }
    impl ::buffa::ExtensionSet for EnumReservedRange {
        const PROTO_FQN: &'static str = "google.protobuf.EnumDescriptorProto.EnumReservedRange";
        fn unknown_fields(&self) -> &::buffa::UnknownFields {
            &self.__buffa_unknown_fields
        }
        fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
            &mut self.__buffa_unknown_fields
        }
    }
    #[cfg(feature = "text")]
    impl ::buffa::text::TextFormat for EnumReservedRange {
        fn encode_text(
            &self,
            enc: &mut ::buffa::text::TextEncoder<'_>,
        ) -> ::core::fmt::Result {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if let ::core::option::Option::Some(ref __v) = self.start {
                enc.write_field_name("start")?;
                enc.write_i32(*__v)?;
            }
            if let ::core::option::Option::Some(ref __v) = self.end {
                enc.write_field_name("end")?;
                enc.write_i32(*__v)?;
            }
            enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
            ::core::result::Result::Ok(())
        }
        fn merge_text(
            &mut self,
            dec: &mut ::buffa::text::TextDecoder<'_>,
        ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
                match __name {
                    "start" => self.start = ::core::option::Option::Some(dec.read_i32()?),
                    "end" => self.end = ::core::option::Option::Some(dec.read_i32()?),
                    _ => dec.skip_value()?,
                }
            }
            ::core::result::Result::Ok(())
        }
    }
    #[cfg(feature = "json")]
    impl ::buffa::json_helpers::ProtoElemJson for EnumReservedRange {
        fn serialize_proto_json<S: ::serde::Serializer>(
            v: &Self,
            s: S,
        ) -> ::core::result::Result<S::Ok, S::Error> {
            ::serde::Serialize::serialize(v, s)
        }
        fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
            d: D,
        ) -> ::core::result::Result<Self, D::Error> {
            <Self as ::serde::Deserialize>::deserialize(d)
        }
    }
    #[cfg(feature = "json")]
    #[doc(hidden)]
    pub const __ENUM_RESERVED_RANGE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.EnumDescriptorProto.EnumReservedRange",
        to_json: ::buffa::type_registry::any_to_json::<EnumReservedRange>,
        from_json: ::buffa::type_registry::any_from_json::<EnumReservedRange>,
        is_wkt: false,
    };
    #[cfg(feature = "text")]
    #[doc(hidden)]
    pub const __ENUM_RESERVED_RANGE_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.EnumDescriptorProto.EnumReservedRange",
        text_encode: ::buffa::type_registry::any_encode_text::<EnumReservedRange>,
        text_merge: ::buffa::type_registry::any_merge_text::<EnumReservedRange>,
    };
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::enum_descriptor_proto::EnumReservedRangeView;
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::enum_descriptor_proto::EnumReservedRangeOwnedView;
}
/// Describes a value within an enum.
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct EnumValueDescriptorProto {
    /// Field 1: `name`
    #[cfg_attr(
        feature = "json",
        serde(rename = "name", skip_serializing_if = "::core::option::Option::is_none")
    )]
    pub name: ::core::option::Option<::buffa::alloc::string::String>,
    /// Field 2: `number`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "number",
            with = "::buffa::json_helpers::opt_int32",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub number: ::core::option::Option<i32>,
    /// Field 3: `options`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "options",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub options: ::buffa::MessageField<
        EnumValueOptions,
        ::buffa::Inline<EnumValueOptions>,
    >,
    #[cfg_attr(feature = "json", serde(skip))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for EnumValueDescriptorProto {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("EnumValueDescriptorProto")
            .field("name", &self.name)
            .field("number", &self.number)
            .field("options", &self.options)
            .finish()
    }
}
impl EnumValueDescriptorProto {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.EnumValueDescriptorProto";
}
impl EnumValueDescriptorProto {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::name`] to `Some(value)`, consuming and returning `self`.
    pub fn with_name(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.name = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::number`] to `Some(value)`, consuming and returning `self`.
    pub fn with_number(mut self, value: i32) -> Self {
        self.number = Some(value);
        self
    }
}
::buffa::impl_default_instance!(EnumValueDescriptorProto);
impl ::buffa::MessageName for EnumValueDescriptorProto {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "EnumValueDescriptorProto";
    const FULL_NAME: &'static str = "google.protobuf.EnumValueDescriptorProto";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.EnumValueDescriptorProto";
}
impl ::buffa::Message for EnumValueDescriptorProto {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if let Some(ref v) = self.name {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(v) = self.number {
            size += 1u64 + ::buffa::types::int32_encoded_len(v) as u64;
        }
        if self.options.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.options.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let Some(ref v) = self.name {
            ::buffa::types::put_string_field(1u32, v, buf);
        }
        if let Some(v) = self.number {
            ::buffa::types::put_int32_field(2u32, v, buf);
        }
        if self.options.is_set() {
            ::buffa::types::put_len_delimited_header(
                3u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.options.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self.name.get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.number = ::core::option::Option::Some(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.options.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.name = ::core::option::Option::None;
        self.number = ::core::option::Option::None;
        self.options = ::buffa::MessageField::none();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for EnumValueDescriptorProto {
    const PROTO_FQN: &'static str = "google.protobuf.EnumValueDescriptorProto";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for EnumValueDescriptorProto {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref __v) = self.name {
            enc.write_field_name("name")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.number {
            enc.write_field_name("number")?;
            enc.write_i32(*__v)?;
        }
        if self.options.is_set() {
            enc.write_field_name("options")?;
            enc.write_message(&*self.options)?;
        }
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "name" => {
                    self.name = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "number" => self.number = ::core::option::Option::Some(dec.read_i32()?),
                "options" => dec.merge_message(self.options.get_or_insert_default())?,
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for EnumValueDescriptorProto {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __ENUM_VALUE_DESCRIPTOR_PROTO_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.EnumValueDescriptorProto",
    to_json: ::buffa::type_registry::any_to_json::<EnumValueDescriptorProto>,
    from_json: ::buffa::type_registry::any_from_json::<EnumValueDescriptorProto>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __ENUM_VALUE_DESCRIPTOR_PROTO_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.EnumValueDescriptorProto",
    text_encode: ::buffa::type_registry::any_encode_text::<EnumValueDescriptorProto>,
    text_merge: ::buffa::type_registry::any_merge_text::<EnumValueDescriptorProto>,
};
/// Describes a service.
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct ServiceDescriptorProto {
    /// Field 1: `name`
    #[cfg_attr(
        feature = "json",
        serde(rename = "name", skip_serializing_if = "::core::option::Option::is_none")
    )]
    pub name: ::core::option::Option<::buffa::alloc::string::String>,
    /// Field 2: `method`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "method",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub method: ::buffa::alloc::vec::Vec<MethodDescriptorProto>,
    /// Field 3: `options`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "options",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub options: ::buffa::MessageField<ServiceOptions, ::buffa::Inline<ServiceOptions>>,
    #[cfg_attr(feature = "json", serde(skip))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for ServiceDescriptorProto {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ServiceDescriptorProto")
            .field("name", &self.name)
            .field("method", &self.method)
            .field("options", &self.options)
            .finish()
    }
}
impl ServiceDescriptorProto {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.ServiceDescriptorProto";
}
impl ServiceDescriptorProto {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::name`] to `Some(value)`, consuming and returning `self`.
    pub fn with_name(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.name = Some(value.into());
        self
    }
}
::buffa::impl_default_instance!(ServiceDescriptorProto);
impl ::buffa::MessageName for ServiceDescriptorProto {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "ServiceDescriptorProto";
    const FULL_NAME: &'static str = "google.protobuf.ServiceDescriptorProto";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.ServiceDescriptorProto";
}
impl ::buffa::Message for ServiceDescriptorProto {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if let Some(ref v) = self.name {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        for v in &self.method {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if self.options.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.options.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let Some(ref v) = self.name {
            ::buffa::types::put_string_field(1u32, v, buf);
        }
        for v in &self.method {
            ::buffa::types::put_len_delimited_header(
                2u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        if self.options.is_set() {
            ::buffa::types::put_len_delimited_header(
                3u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.options.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self.name.get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.method.push(elem);
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.options.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.name = ::core::option::Option::None;
        self.method.clear();
        self.options = ::buffa::MessageField::none();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ServiceDescriptorProto {
    const PROTO_FQN: &'static str = "google.protobuf.ServiceDescriptorProto";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for ServiceDescriptorProto {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref __v) = self.name {
            enc.write_field_name("name")?;
            enc.write_string(__v)?;
        }
        if self.options.is_set() {
            enc.write_field_name("options")?;
            enc.write_message(&*self.options)?;
        }
        for __v in &self.method {
            enc.write_field_name("method")?;
            enc.write_message(__v)?;
        }
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "name" => {
                    self.name = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "options" => dec.merge_message(self.options.get_or_insert_default())?,
                "method" => {
                    dec.read_repeated_into(
                        &mut self.method,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for ServiceDescriptorProto {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __SERVICE_DESCRIPTOR_PROTO_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.ServiceDescriptorProto",
    to_json: ::buffa::type_registry::any_to_json::<ServiceDescriptorProto>,
    from_json: ::buffa::type_registry::any_from_json::<ServiceDescriptorProto>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __SERVICE_DESCRIPTOR_PROTO_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.ServiceDescriptorProto",
    text_encode: ::buffa::type_registry::any_encode_text::<ServiceDescriptorProto>,
    text_merge: ::buffa::type_registry::any_merge_text::<ServiceDescriptorProto>,
};
/// Describes a method of a service.
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct MethodDescriptorProto {
    /// Field 1: `name`
    #[cfg_attr(
        feature = "json",
        serde(rename = "name", skip_serializing_if = "::core::option::Option::is_none")
    )]
    pub name: ::core::option::Option<::buffa::alloc::string::String>,
    /// Input and output type names.  These are resolved in the same way as
    /// FieldDescriptorProto.type_name, but must refer to a message type.
    ///
    /// Field 2: `input_type`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "inputType",
            alias = "input_type",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub input_type: ::core::option::Option<::buffa::alloc::string::String>,
    /// Field 3: `output_type`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "outputType",
            alias = "output_type",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub output_type: ::core::option::Option<::buffa::alloc::string::String>,
    /// Field 4: `options`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "options",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub options: ::buffa::MessageField<MethodOptions, ::buffa::Inline<MethodOptions>>,
    /// Identifies if client streams multiple client messages
    ///
    /// Field 5: `client_streaming`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "clientStreaming",
            alias = "client_streaming",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub client_streaming: ::core::option::Option<bool>,
    /// Identifies if server streams multiple server messages
    ///
    /// Field 6: `server_streaming`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "serverStreaming",
            alias = "server_streaming",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub server_streaming: ::core::option::Option<bool>,
    #[cfg_attr(feature = "json", serde(skip))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for MethodDescriptorProto {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("MethodDescriptorProto")
            .field("name", &self.name)
            .field("input_type", &self.input_type)
            .field("output_type", &self.output_type)
            .field("options", &self.options)
            .field("client_streaming", &self.client_streaming)
            .field("server_streaming", &self.server_streaming)
            .finish()
    }
}
impl MethodDescriptorProto {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.MethodDescriptorProto";
}
impl MethodDescriptorProto {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::name`] to `Some(value)`, consuming and returning `self`.
    pub fn with_name(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.name = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::input_type`] to `Some(value)`, consuming and returning `self`.
    pub fn with_input_type(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.input_type = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::output_type`] to `Some(value)`, consuming and returning `self`.
    pub fn with_output_type(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.output_type = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::client_streaming`] to `Some(value)`, consuming and returning `self`.
    pub fn with_client_streaming(mut self, value: bool) -> Self {
        self.client_streaming = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::server_streaming`] to `Some(value)`, consuming and returning `self`.
    pub fn with_server_streaming(mut self, value: bool) -> Self {
        self.server_streaming = Some(value);
        self
    }
}
::buffa::impl_default_instance!(MethodDescriptorProto);
impl ::buffa::MessageName for MethodDescriptorProto {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "MethodDescriptorProto";
    const FULL_NAME: &'static str = "google.protobuf.MethodDescriptorProto";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.MethodDescriptorProto";
}
impl ::buffa::Message for MethodDescriptorProto {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if let Some(ref v) = self.name {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.input_type {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.output_type {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if self.options.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.options.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if self.client_streaming.is_some() {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.server_streaming.is_some() {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let Some(ref v) = self.name {
            ::buffa::types::put_string_field(1u32, v, buf);
        }
        if let Some(ref v) = self.input_type {
            ::buffa::types::put_string_field(2u32, v, buf);
        }
        if let Some(ref v) = self.output_type {
            ::buffa::types::put_string_field(3u32, v, buf);
        }
        if self.options.is_set() {
            ::buffa::types::put_len_delimited_header(
                4u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.options.write_to(__cache, buf);
        }
        if let Some(v) = self.client_streaming {
            ::buffa::types::put_bool_field(5u32, v, buf);
        }
        if let Some(v) = self.server_streaming {
            ::buffa::types::put_bool_field(6u32, v, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self.name.get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self
                        .input_type
                        .get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self
                        .output_type
                        .get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.options.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.client_streaming = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.server_streaming = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.name = ::core::option::Option::None;
        self.input_type = ::core::option::Option::None;
        self.output_type = ::core::option::Option::None;
        self.options = ::buffa::MessageField::none();
        self.client_streaming = ::core::option::Option::None;
        self.server_streaming = ::core::option::Option::None;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for MethodDescriptorProto {
    const PROTO_FQN: &'static str = "google.protobuf.MethodDescriptorProto";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for MethodDescriptorProto {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref __v) = self.name {
            enc.write_field_name("name")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.input_type {
            enc.write_field_name("input_type")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.output_type {
            enc.write_field_name("output_type")?;
            enc.write_string(__v)?;
        }
        if self.options.is_set() {
            enc.write_field_name("options")?;
            enc.write_message(&*self.options)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.client_streaming {
            enc.write_field_name("client_streaming")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.server_streaming {
            enc.write_field_name("server_streaming")?;
            enc.write_bool(*__v)?;
        }
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "name" => {
                    self.name = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "input_type" => {
                    self.input_type = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "output_type" => {
                    self.output_type = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "options" => dec.merge_message(self.options.get_or_insert_default())?,
                "client_streaming" => {
                    self.client_streaming = ::core::option::Option::Some(
                        dec.read_bool()?,
                    );
                }
                "server_streaming" => {
                    self.server_streaming = ::core::option::Option::Some(
                        dec.read_bool()?,
                    );
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for MethodDescriptorProto {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __METHOD_DESCRIPTOR_PROTO_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.MethodDescriptorProto",
    to_json: ::buffa::type_registry::any_to_json::<MethodDescriptorProto>,
    from_json: ::buffa::type_registry::any_from_json::<MethodDescriptorProto>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __METHOD_DESCRIPTOR_PROTO_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.MethodDescriptorProto",
    text_encode: ::buffa::type_registry::any_encode_text::<MethodDescriptorProto>,
    text_merge: ::buffa::type_registry::any_merge_text::<MethodDescriptorProto>,
};
/// ===================================================================
/// Options
///
/// Each of the definitions above may have "options" attached.  These are
/// just annotations which may cause code to be generated slightly differently
/// or may contain hints for code that manipulates protocol messages.
///
/// Clients may define custom options as extensions of the *Options messages.
/// These extensions may not yet be known at parsing time, so the parser cannot
/// store the values in them.  Instead it stores them in a field in the *Options
/// message called uninterpreted_option. This field must have the same name
/// across all *Options messages. We then use this field to populate the
/// extensions when we build a descriptor, at which point all protos have been
/// parsed and so all extensions are known.
///
/// Extension numbers for custom options may be chosen as follows:
/// * For options which will only be used within a single application or
///   organization, or for experimental options, use field numbers 50000
///   through 99999.  It is up to you to ensure that you do not use the
///   same number for multiple options.
/// * For options which will be published and used publicly by multiple
///   independent entities, e-mail protobuf-global-extension-registry@google.com
///   to reserve extension numbers. Simply provide your project name (e.g.
///   Objective-C plugin) and your project website (if available) -- there's no
///   need to explain how you intend to use them. Usually you only need one
///   extension number. You can declare multiple options with only one extension
///   number by putting them in a sub-message. See the Custom Options section of
///   the docs for examples:
///   <https://developers.google.com/protocol-buffers/docs/proto#options>
///   If this turns out to be popular, a web service will be set up
///   to automatically assign option numbers.
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct FileOptions {
    /// Sets the Java package where classes generated from this .proto will be
    /// placed.  By default, the proto package is used, but this is often
    /// inappropriate because proto packages do not normally start with backwards
    /// domain names.
    ///
    /// Field 1: `java_package`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "javaPackage",
            alias = "java_package",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub java_package: ::core::option::Option<::buffa::alloc::string::String>,
    /// Controls the name of the wrapper Java class generated for the .proto file.
    /// That class will always contain the .proto file's getDescriptor() method as
    /// well as any top-level extensions defined in the .proto file.
    /// If java_multiple_files is disabled, then all the other classes from the
    /// .proto file will be nested inside the single wrapper outer class.
    ///
    /// Field 8: `java_outer_classname`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "javaOuterClassname",
            alias = "java_outer_classname",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub java_outer_classname: ::core::option::Option<::buffa::alloc::string::String>,
    /// If enabled, then the Java code generator will generate a separate .java
    /// file for each top-level message, enum, and service defined in the .proto
    /// file.  Thus, these types will *not* be nested inside the wrapper class
    /// named by java_outer_classname.  However, the wrapper class will still be
    /// generated to contain the file's getDescriptor() method as well as any
    /// top-level extensions defined in the file.
    ///
    /// Field 10: `java_multiple_files`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "javaMultipleFiles",
            alias = "java_multiple_files",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub java_multiple_files: ::core::option::Option<bool>,
    /// This option does nothing.
    ///
    /// Field 20: `java_generate_equals_and_hash`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "javaGenerateEqualsAndHash",
            alias = "java_generate_equals_and_hash",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub java_generate_equals_and_hash: ::core::option::Option<bool>,
    /// A proto2 file can set this to true to opt in to UTF-8 checking for Java,
    /// which will throw an exception if invalid UTF-8 is parsed from the wire or
    /// assigned to a string field.
    ///
    /// TODO: clarify exactly what kinds of field types this option
    /// applies to, and update these docs accordingly.
    ///
    /// Proto3 files already perform these checks. Setting the option explicitly to
    /// false has no effect: it cannot be used to opt proto3 files out of UTF-8
    /// checks.
    ///
    /// Field 27: `java_string_check_utf8`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "javaStringCheckUtf8",
            alias = "java_string_check_utf8",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub java_string_check_utf8: ::core::option::Option<bool>,
    /// Field 9: `optimize_for`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "optimizeFor",
            alias = "optimize_for",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub optimize_for: ::core::option::Option<file_options::OptimizeMode>,
    /// Sets the Go package where structs generated from this .proto will be
    /// placed. If omitted, the Go package will be derived from the following:
    ///   - The basename of the package import path, if provided.
    ///   - Otherwise, the package statement in the .proto file, if present.
    ///   - Otherwise, the basename of the .proto file, without extension.
    ///
    /// Field 11: `go_package`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "goPackage",
            alias = "go_package",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub go_package: ::core::option::Option<::buffa::alloc::string::String>,
    /// Should generic services be generated in each language?  "Generic" services
    /// are not specific to any particular RPC system.  They are generated by the
    /// main code generators in each language (without additional plugins).
    /// Generic services were the only kind of service generation supported by
    /// early versions of google.protobuf.
    ///
    /// Generic services are now considered deprecated in favor of using plugins
    /// that generate code specific to your particular RPC system.  Therefore,
    /// these default to false.  Old code which depends on generic services should
    /// explicitly set them to true.
    ///
    /// Field 16: `cc_generic_services`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "ccGenericServices",
            alias = "cc_generic_services",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub cc_generic_services: ::core::option::Option<bool>,
    /// Field 17: `java_generic_services`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "javaGenericServices",
            alias = "java_generic_services",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub java_generic_services: ::core::option::Option<bool>,
    /// Field 18: `py_generic_services`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "pyGenericServices",
            alias = "py_generic_services",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub py_generic_services: ::core::option::Option<bool>,
    /// Is this file deprecated?
    /// Depending on the target platform, this can emit Deprecated annotations
    /// for everything in the file, or it will be completely ignored; in the very
    /// least, this is a formalization for deprecating files.
    ///
    /// Field 23: `deprecated`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "deprecated",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub deprecated: ::core::option::Option<bool>,
    /// Enables the use of arenas for the proto messages in this file. This applies
    /// only to generated classes for C++.
    ///
    /// Field 31: `cc_enable_arenas`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "ccEnableArenas",
            alias = "cc_enable_arenas",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub cc_enable_arenas: ::core::option::Option<bool>,
    /// Sets the objective c class prefix which is prepended to all objective c
    /// generated classes from this .proto. There is no default.
    ///
    /// Field 36: `objc_class_prefix`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "objcClassPrefix",
            alias = "objc_class_prefix",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub objc_class_prefix: ::core::option::Option<::buffa::alloc::string::String>,
    /// Namespace for generated classes; defaults to the package.
    ///
    /// Field 37: `csharp_namespace`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "csharpNamespace",
            alias = "csharp_namespace",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub csharp_namespace: ::core::option::Option<::buffa::alloc::string::String>,
    /// By default Swift generators will take the proto package and CamelCase it
    /// replacing '.' with underscore and use that to prefix the types/symbols
    /// defined. When this options is provided, they will use this value instead
    /// to prefix the types/symbols defined.
    ///
    /// Field 39: `swift_prefix`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "swiftPrefix",
            alias = "swift_prefix",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub swift_prefix: ::core::option::Option<::buffa::alloc::string::String>,
    /// Sets the php class prefix which is prepended to all php generated classes
    /// from this .proto. Default is empty.
    ///
    /// Field 40: `php_class_prefix`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "phpClassPrefix",
            alias = "php_class_prefix",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub php_class_prefix: ::core::option::Option<::buffa::alloc::string::String>,
    /// Use this option to change the namespace of php generated classes. Default
    /// is empty. When this option is empty, the package name will be used for
    /// determining the namespace.
    ///
    /// Field 41: `php_namespace`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "phpNamespace",
            alias = "php_namespace",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub php_namespace: ::core::option::Option<::buffa::alloc::string::String>,
    /// Use this option to change the namespace of php generated metadata classes.
    /// Default is empty. When this option is empty, the proto file name will be
    /// used for determining the namespace.
    ///
    /// Field 44: `php_metadata_namespace`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "phpMetadataNamespace",
            alias = "php_metadata_namespace",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub php_metadata_namespace: ::core::option::Option<::buffa::alloc::string::String>,
    /// Use this option to change the package of ruby generated classes. Default
    /// is empty. When this option is not set, the package name will be used for
    /// determining the ruby package.
    ///
    /// Field 45: `ruby_package`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "rubyPackage",
            alias = "ruby_package",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub ruby_package: ::core::option::Option<::buffa::alloc::string::String>,
    /// Any features defined in the specific edition.
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    ///
    /// Field 50: `features`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "features",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub features: ::buffa::MessageField<FeatureSet, ::buffa::Inline<FeatureSet>>,
    /// The parser stores options it doesn't recognize here.
    /// See the documentation for the "Options" section above.
    ///
    /// Field 999: `uninterpreted_option`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "uninterpretedOption",
            alias = "uninterpreted_option",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub uninterpreted_option: ::buffa::alloc::vec::Vec<UninterpretedOption>,
    #[cfg_attr(feature = "json", serde(flatten))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: __FileOptionsExtJson,
}
impl ::core::fmt::Debug for FileOptions {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("FileOptions")
            .field("java_package", &self.java_package)
            .field("java_outer_classname", &self.java_outer_classname)
            .field("java_multiple_files", &self.java_multiple_files)
            .field("java_generate_equals_and_hash", &self.java_generate_equals_and_hash)
            .field("java_string_check_utf8", &self.java_string_check_utf8)
            .field("optimize_for", &self.optimize_for)
            .field("go_package", &self.go_package)
            .field("cc_generic_services", &self.cc_generic_services)
            .field("java_generic_services", &self.java_generic_services)
            .field("py_generic_services", &self.py_generic_services)
            .field("deprecated", &self.deprecated)
            .field("cc_enable_arenas", &self.cc_enable_arenas)
            .field("objc_class_prefix", &self.objc_class_prefix)
            .field("csharp_namespace", &self.csharp_namespace)
            .field("swift_prefix", &self.swift_prefix)
            .field("php_class_prefix", &self.php_class_prefix)
            .field("php_namespace", &self.php_namespace)
            .field("php_metadata_namespace", &self.php_metadata_namespace)
            .field("ruby_package", &self.ruby_package)
            .field("features", &self.features)
            .field("uninterpreted_option", &self.uninterpreted_option)
            .finish()
    }
}
impl FileOptions {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FileOptions";
}
impl FileOptions {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::java_package`] to `Some(value)`, consuming and returning `self`.
    pub fn with_java_package(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.java_package = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::java_outer_classname`] to `Some(value)`, consuming and returning `self`.
    pub fn with_java_outer_classname(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.java_outer_classname = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::java_multiple_files`] to `Some(value)`, consuming and returning `self`.
    pub fn with_java_multiple_files(mut self, value: bool) -> Self {
        self.java_multiple_files = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::java_generate_equals_and_hash`] to `Some(value)`, consuming and returning `self`.
    pub fn with_java_generate_equals_and_hash(mut self, value: bool) -> Self {
        self.java_generate_equals_and_hash = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::java_string_check_utf8`] to `Some(value)`, consuming and returning `self`.
    pub fn with_java_string_check_utf8(mut self, value: bool) -> Self {
        self.java_string_check_utf8 = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::optimize_for`] to `Some(value)`, consuming and returning `self`.
    pub fn with_optimize_for(
        mut self,
        value: impl Into<file_options::OptimizeMode>,
    ) -> Self {
        self.optimize_for = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::go_package`] to `Some(value)`, consuming and returning `self`.
    pub fn with_go_package(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.go_package = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::cc_generic_services`] to `Some(value)`, consuming and returning `self`.
    pub fn with_cc_generic_services(mut self, value: bool) -> Self {
        self.cc_generic_services = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::java_generic_services`] to `Some(value)`, consuming and returning `self`.
    pub fn with_java_generic_services(mut self, value: bool) -> Self {
        self.java_generic_services = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::py_generic_services`] to `Some(value)`, consuming and returning `self`.
    pub fn with_py_generic_services(mut self, value: bool) -> Self {
        self.py_generic_services = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::deprecated`] to `Some(value)`, consuming and returning `self`.
    pub fn with_deprecated(mut self, value: bool) -> Self {
        self.deprecated = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::cc_enable_arenas`] to `Some(value)`, consuming and returning `self`.
    pub fn with_cc_enable_arenas(mut self, value: bool) -> Self {
        self.cc_enable_arenas = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::objc_class_prefix`] to `Some(value)`, consuming and returning `self`.
    pub fn with_objc_class_prefix(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.objc_class_prefix = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::csharp_namespace`] to `Some(value)`, consuming and returning `self`.
    pub fn with_csharp_namespace(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.csharp_namespace = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::swift_prefix`] to `Some(value)`, consuming and returning `self`.
    pub fn with_swift_prefix(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.swift_prefix = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::php_class_prefix`] to `Some(value)`, consuming and returning `self`.
    pub fn with_php_class_prefix(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.php_class_prefix = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::php_namespace`] to `Some(value)`, consuming and returning `self`.
    pub fn with_php_namespace(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.php_namespace = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::php_metadata_namespace`] to `Some(value)`, consuming and returning `self`.
    pub fn with_php_metadata_namespace(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.php_metadata_namespace = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::ruby_package`] to `Some(value)`, consuming and returning `self`.
    pub fn with_ruby_package(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.ruby_package = Some(value.into());
        self
    }
}
::buffa::impl_default_instance!(FileOptions);
impl ::buffa::MessageName for FileOptions {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "FileOptions";
    const FULL_NAME: &'static str = "google.protobuf.FileOptions";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FileOptions";
}
impl ::buffa::Message for FileOptions {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if let Some(ref v) = self.java_package {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.java_outer_classname {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.optimize_for {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        if self.java_multiple_files.is_some() {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if let Some(ref v) = self.go_package {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if self.cc_generic_services.is_some() {
            size += 2u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.java_generic_services.is_some() {
            size += 2u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.py_generic_services.is_some() {
            size += 2u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.java_generate_equals_and_hash.is_some() {
            size += 2u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.deprecated.is_some() {
            size += 2u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.java_string_check_utf8.is_some() {
            size += 2u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.cc_enable_arenas.is_some() {
            size += 2u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if let Some(ref v) = self.objc_class_prefix {
            size += 2u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.csharp_namespace {
            size += 2u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.swift_prefix {
            size += 2u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.php_class_prefix {
            size += 2u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.php_namespace {
            size += 2u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.php_metadata_namespace {
            size += 2u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.ruby_package {
            size += 2u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if self.features.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.features.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 2u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.uninterpreted_option {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 2u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let Some(ref v) = self.java_package {
            ::buffa::types::put_string_field(1u32, v, buf);
        }
        if let Some(ref v) = self.java_outer_classname {
            ::buffa::types::put_string_field(8u32, v, buf);
        }
        if let Some(ref v) = self.optimize_for {
            ::buffa::types::put_int32_field(9u32, v.to_i32(), buf);
        }
        if let Some(v) = self.java_multiple_files {
            ::buffa::types::put_bool_field(10u32, v, buf);
        }
        if let Some(ref v) = self.go_package {
            ::buffa::types::put_string_field(11u32, v, buf);
        }
        if let Some(v) = self.cc_generic_services {
            ::buffa::types::put_bool_field(16u32, v, buf);
        }
        if let Some(v) = self.java_generic_services {
            ::buffa::types::put_bool_field(17u32, v, buf);
        }
        if let Some(v) = self.py_generic_services {
            ::buffa::types::put_bool_field(18u32, v, buf);
        }
        if let Some(v) = self.java_generate_equals_and_hash {
            ::buffa::types::put_bool_field(20u32, v, buf);
        }
        if let Some(v) = self.deprecated {
            ::buffa::types::put_bool_field(23u32, v, buf);
        }
        if let Some(v) = self.java_string_check_utf8 {
            ::buffa::types::put_bool_field(27u32, v, buf);
        }
        if let Some(v) = self.cc_enable_arenas {
            ::buffa::types::put_bool_field(31u32, v, buf);
        }
        if let Some(ref v) = self.objc_class_prefix {
            ::buffa::types::put_string_field(36u32, v, buf);
        }
        if let Some(ref v) = self.csharp_namespace {
            ::buffa::types::put_string_field(37u32, v, buf);
        }
        if let Some(ref v) = self.swift_prefix {
            ::buffa::types::put_string_field(39u32, v, buf);
        }
        if let Some(ref v) = self.php_class_prefix {
            ::buffa::types::put_string_field(40u32, v, buf);
        }
        if let Some(ref v) = self.php_namespace {
            ::buffa::types::put_string_field(41u32, v, buf);
        }
        if let Some(ref v) = self.php_metadata_namespace {
            ::buffa::types::put_string_field(44u32, v, buf);
        }
        if let Some(ref v) = self.ruby_package {
            ::buffa::types::put_string_field(45u32, v, buf);
        }
        if self.features.is_set() {
            ::buffa::types::put_len_delimited_header(
                50u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.features.write_to(__cache, buf);
        }
        for v in &self.uninterpreted_option {
            ::buffa::types::put_len_delimited_header(
                999u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self
                        .java_package
                        .get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self
                        .java_outer_classname
                        .get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            9u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.optimize_for = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 9u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            10u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.java_multiple_files = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            11u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self
                        .go_package
                        .get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            16u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.cc_generic_services = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            17u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.java_generic_services = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            18u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.py_generic_services = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            20u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.java_generate_equals_and_hash = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            23u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.deprecated = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            27u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.java_string_check_utf8 = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            31u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.cc_enable_arenas = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            36u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self
                        .objc_class_prefix
                        .get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            37u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self
                        .csharp_namespace
                        .get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            39u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self
                        .swift_prefix
                        .get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            40u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self
                        .php_class_prefix
                        .get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            41u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self
                        .php_namespace
                        .get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            44u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self
                        .php_metadata_namespace
                        .get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            45u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self
                        .ruby_package
                        .get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            50u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.features.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            999u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.uninterpreted_option.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.java_package = ::core::option::Option::None;
        self.java_outer_classname = ::core::option::Option::None;
        self.optimize_for = ::core::option::Option::None;
        self.java_multiple_files = ::core::option::Option::None;
        self.go_package = ::core::option::Option::None;
        self.cc_generic_services = ::core::option::Option::None;
        self.java_generic_services = ::core::option::Option::None;
        self.py_generic_services = ::core::option::Option::None;
        self.java_generate_equals_and_hash = ::core::option::Option::None;
        self.deprecated = ::core::option::Option::None;
        self.java_string_check_utf8 = ::core::option::Option::None;
        self.cc_enable_arenas = ::core::option::Option::None;
        self.objc_class_prefix = ::core::option::Option::None;
        self.csharp_namespace = ::core::option::Option::None;
        self.swift_prefix = ::core::option::Option::None;
        self.php_class_prefix = ::core::option::Option::None;
        self.php_namespace = ::core::option::Option::None;
        self.php_metadata_namespace = ::core::option::Option::None;
        self.ruby_package = ::core::option::Option::None;
        self.features = ::buffa::MessageField::none();
        self.uninterpreted_option.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for FileOptions {
    const PROTO_FQN: &'static str = "google.protobuf.FileOptions";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for FileOptions {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref __v) = self.java_package {
            enc.write_field_name("java_package")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.java_outer_classname {
            enc.write_field_name("java_outer_classname")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.java_multiple_files {
            enc.write_field_name("java_multiple_files")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.java_generate_equals_and_hash
        {
            enc.write_field_name("java_generate_equals_and_hash")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.java_string_check_utf8 {
            enc.write_field_name("java_string_check_utf8")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.optimize_for {
            enc.write_field_name("optimize_for")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        if let ::core::option::Option::Some(ref __v) = self.go_package {
            enc.write_field_name("go_package")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.cc_generic_services {
            enc.write_field_name("cc_generic_services")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.java_generic_services {
            enc.write_field_name("java_generic_services")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.py_generic_services {
            enc.write_field_name("py_generic_services")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.deprecated {
            enc.write_field_name("deprecated")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.cc_enable_arenas {
            enc.write_field_name("cc_enable_arenas")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.objc_class_prefix {
            enc.write_field_name("objc_class_prefix")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.csharp_namespace {
            enc.write_field_name("csharp_namespace")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.swift_prefix {
            enc.write_field_name("swift_prefix")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.php_class_prefix {
            enc.write_field_name("php_class_prefix")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.php_namespace {
            enc.write_field_name("php_namespace")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.php_metadata_namespace {
            enc.write_field_name("php_metadata_namespace")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.ruby_package {
            enc.write_field_name("ruby_package")?;
            enc.write_string(__v)?;
        }
        if self.features.is_set() {
            enc.write_field_name("features")?;
            enc.write_message(&*self.features)?;
        }
        for __v in &self.uninterpreted_option {
            enc.write_field_name("uninterpreted_option")?;
            enc.write_message(__v)?;
        }
        enc.write_extension_fields(
            "google.protobuf.FileOptions",
            &self.__buffa_unknown_fields,
        )?;
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "java_package" => {
                    self.java_package = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "java_outer_classname" => {
                    self.java_outer_classname = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "java_multiple_files" => {
                    self.java_multiple_files = ::core::option::Option::Some(
                        dec.read_bool()?,
                    );
                }
                "java_generate_equals_and_hash" => {
                    self.java_generate_equals_and_hash = ::core::option::Option::Some(
                        dec.read_bool()?,
                    );
                }
                "java_string_check_utf8" => {
                    self.java_string_check_utf8 = ::core::option::Option::Some(
                        dec.read_bool()?,
                    );
                }
                "optimize_for" => {
                    self.optimize_for = ::core::option::Option::Some(
                        dec.read_closed_enum_by_name::<file_options::OptimizeMode>()?,
                    );
                }
                "go_package" => {
                    self.go_package = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "cc_generic_services" => {
                    self.cc_generic_services = ::core::option::Option::Some(
                        dec.read_bool()?,
                    );
                }
                "java_generic_services" => {
                    self.java_generic_services = ::core::option::Option::Some(
                        dec.read_bool()?,
                    );
                }
                "py_generic_services" => {
                    self.py_generic_services = ::core::option::Option::Some(
                        dec.read_bool()?,
                    );
                }
                "deprecated" => {
                    self.deprecated = ::core::option::Option::Some(dec.read_bool()?);
                }
                "cc_enable_arenas" => {
                    self.cc_enable_arenas = ::core::option::Option::Some(
                        dec.read_bool()?,
                    );
                }
                "objc_class_prefix" => {
                    self.objc_class_prefix = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "csharp_namespace" => {
                    self.csharp_namespace = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "swift_prefix" => {
                    self.swift_prefix = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "php_class_prefix" => {
                    self.php_class_prefix = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "php_namespace" => {
                    self.php_namespace = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "php_metadata_namespace" => {
                    self.php_metadata_namespace = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "ruby_package" => {
                    self.ruby_package = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "features" => dec.merge_message(self.features.get_or_insert_default())?,
                "uninterpreted_option" => {
                    dec.read_repeated_into(
                        &mut self.uninterpreted_option,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                __name if __name.starts_with('[') => {
                    for __r in dec.read_extension(__name, "google.protobuf.FileOptions")?
                    {
                        self.__buffa_unknown_fields.push(__r);
                    }
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl<'de> serde::Deserialize<'de> for FileOptions {
    fn deserialize<D: serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl<'de> serde::de::Visitor<'de> for _V {
            type Value = FileOptions;
            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                f.write_str("struct FileOptions")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<FileOptions, A::Error> {
                let mut __f_java_package: ::core::option::Option<
                    ::core::option::Option<::buffa::alloc::string::String>,
                > = None;
                let mut __f_java_outer_classname: ::core::option::Option<
                    ::core::option::Option<::buffa::alloc::string::String>,
                > = None;
                let mut __f_java_multiple_files: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_java_generate_equals_and_hash: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_java_string_check_utf8: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_optimize_for: ::core::option::Option<
                    ::core::option::Option<file_options::OptimizeMode>,
                > = None;
                let mut __f_go_package: ::core::option::Option<
                    ::core::option::Option<::buffa::alloc::string::String>,
                > = None;
                let mut __f_cc_generic_services: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_java_generic_services: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_py_generic_services: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_deprecated: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_cc_enable_arenas: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_objc_class_prefix: ::core::option::Option<
                    ::core::option::Option<::buffa::alloc::string::String>,
                > = None;
                let mut __f_csharp_namespace: ::core::option::Option<
                    ::core::option::Option<::buffa::alloc::string::String>,
                > = None;
                let mut __f_swift_prefix: ::core::option::Option<
                    ::core::option::Option<::buffa::alloc::string::String>,
                > = None;
                let mut __f_php_class_prefix: ::core::option::Option<
                    ::core::option::Option<::buffa::alloc::string::String>,
                > = None;
                let mut __f_php_namespace: ::core::option::Option<
                    ::core::option::Option<::buffa::alloc::string::String>,
                > = None;
                let mut __f_php_metadata_namespace: ::core::option::Option<
                    ::core::option::Option<::buffa::alloc::string::String>,
                > = None;
                let mut __f_ruby_package: ::core::option::Option<
                    ::core::option::Option<::buffa::alloc::string::String>,
                > = None;
                let mut __f_features: ::core::option::Option<
                    ::buffa::MessageField<FeatureSet, ::buffa::Inline<FeatureSet>>,
                > = None;
                let mut __f_uninterpreted_option: ::core::option::Option<
                    ::buffa::alloc::vec::Vec<UninterpretedOption>,
                > = None;
                let mut __ext_records: ::buffa::alloc::vec::Vec<::buffa::UnknownField> = ::buffa::alloc::vec::Vec::new();
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "javaPackage" | "java_package" => {
                            __f_java_package = Some(
                                map
                                    .next_value::<
                                        ::core::option::Option<::buffa::alloc::string::String>,
                                    >()?,
                            );
                        }
                        "javaOuterClassname" | "java_outer_classname" => {
                            __f_java_outer_classname = Some(
                                map
                                    .next_value::<
                                        ::core::option::Option<::buffa::alloc::string::String>,
                                    >()?,
                            );
                        }
                        "javaMultipleFiles" | "java_multiple_files" => {
                            __f_java_multiple_files = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "javaGenerateEqualsAndHash"
                        | "java_generate_equals_and_hash" => {
                            __f_java_generate_equals_and_hash = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "javaStringCheckUtf8" | "java_string_check_utf8" => {
                            __f_java_string_check_utf8 = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "optimizeFor" | "optimize_for" => {
                            __f_optimize_for = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::core::option::Option<
                                        file_options::OptimizeMode,
                                    >;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::core::option::Option<file_options::OptimizeMode>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::opt_closed_enum::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "goPackage" | "go_package" => {
                            __f_go_package = Some(
                                map
                                    .next_value::<
                                        ::core::option::Option<::buffa::alloc::string::String>,
                                    >()?,
                            );
                        }
                        "ccGenericServices" | "cc_generic_services" => {
                            __f_cc_generic_services = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "javaGenericServices" | "java_generic_services" => {
                            __f_java_generic_services = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "pyGenericServices" | "py_generic_services" => {
                            __f_py_generic_services = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "deprecated" => {
                            __f_deprecated = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "ccEnableArenas" | "cc_enable_arenas" => {
                            __f_cc_enable_arenas = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "objcClassPrefix" | "objc_class_prefix" => {
                            __f_objc_class_prefix = Some(
                                map
                                    .next_value::<
                                        ::core::option::Option<::buffa::alloc::string::String>,
                                    >()?,
                            );
                        }
                        "csharpNamespace" | "csharp_namespace" => {
                            __f_csharp_namespace = Some(
                                map
                                    .next_value::<
                                        ::core::option::Option<::buffa::alloc::string::String>,
                                    >()?,
                            );
                        }
                        "swiftPrefix" | "swift_prefix" => {
                            __f_swift_prefix = Some(
                                map
                                    .next_value::<
                                        ::core::option::Option<::buffa::alloc::string::String>,
                                    >()?,
                            );
                        }
                        "phpClassPrefix" | "php_class_prefix" => {
                            __f_php_class_prefix = Some(
                                map
                                    .next_value::<
                                        ::core::option::Option<::buffa::alloc::string::String>,
                                    >()?,
                            );
                        }
                        "phpNamespace" | "php_namespace" => {
                            __f_php_namespace = Some(
                                map
                                    .next_value::<
                                        ::core::option::Option<::buffa::alloc::string::String>,
                                    >()?,
                            );
                        }
                        "phpMetadataNamespace" | "php_metadata_namespace" => {
                            __f_php_metadata_namespace = Some(
                                map
                                    .next_value::<
                                        ::core::option::Option<::buffa::alloc::string::String>,
                                    >()?,
                            );
                        }
                        "rubyPackage" | "ruby_package" => {
                            __f_ruby_package = Some(
                                map
                                    .next_value::<
                                        ::core::option::Option<::buffa::alloc::string::String>,
                                    >()?,
                            );
                        }
                        "features" => {
                            __f_features = Some(
                                map
                                    .next_value::<
                                        ::buffa::MessageField<
                                            FeatureSet,
                                            ::buffa::Inline<FeatureSet>,
                                        >,
                                    >()?,
                            );
                        }
                        "uninterpretedOption" | "uninterpreted_option" => {
                            __f_uninterpreted_option = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::buffa::alloc::vec::Vec<UninterpretedOption>;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::buffa::alloc::vec::Vec<UninterpretedOption>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::null_as_default(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        __k if __k.starts_with('[') => {
                            let __v: ::buffa::serde_json::Value = map.next_value()?;
                            match ::buffa::extension_registry::deserialize_extension_key(
                                "google.protobuf.FileOptions",
                                __k,
                                __v,
                            ) {
                                ::core::option::Option::Some(
                                    ::core::result::Result::Ok(__recs),
                                ) => {
                                    for __rec in __recs {
                                        __ext_records.push(__rec);
                                    }
                                }
                                ::core::option::Option::Some(
                                    ::core::result::Result::Err(__e),
                                ) => {
                                    return ::core::result::Result::Err(
                                        <A::Error as ::serde::de::Error>::custom(__e),
                                    );
                                }
                                ::core::option::Option::None => {}
                            }
                        }
                        _ => {
                            map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                let mut __r = <FileOptions as ::core::default::Default>::default();
                if let ::core::option::Option::Some(v) = __f_java_package {
                    __r.java_package = v;
                }
                if let ::core::option::Option::Some(v) = __f_java_outer_classname {
                    __r.java_outer_classname = v;
                }
                if let ::core::option::Option::Some(v) = __f_java_multiple_files {
                    __r.java_multiple_files = v;
                }
                if let ::core::option::Option::Some(v) = __f_java_generate_equals_and_hash {
                    __r.java_generate_equals_and_hash = v;
                }
                if let ::core::option::Option::Some(v) = __f_java_string_check_utf8 {
                    __r.java_string_check_utf8 = v;
                }
                if let ::core::option::Option::Some(v) = __f_optimize_for {
                    __r.optimize_for = v;
                }
                if let ::core::option::Option::Some(v) = __f_go_package {
                    __r.go_package = v;
                }
                if let ::core::option::Option::Some(v) = __f_cc_generic_services {
                    __r.cc_generic_services = v;
                }
                if let ::core::option::Option::Some(v) = __f_java_generic_services {
                    __r.java_generic_services = v;
                }
                if let ::core::option::Option::Some(v) = __f_py_generic_services {
                    __r.py_generic_services = v;
                }
                if let ::core::option::Option::Some(v) = __f_deprecated {
                    __r.deprecated = v;
                }
                if let ::core::option::Option::Some(v) = __f_cc_enable_arenas {
                    __r.cc_enable_arenas = v;
                }
                if let ::core::option::Option::Some(v) = __f_objc_class_prefix {
                    __r.objc_class_prefix = v;
                }
                if let ::core::option::Option::Some(v) = __f_csharp_namespace {
                    __r.csharp_namespace = v;
                }
                if let ::core::option::Option::Some(v) = __f_swift_prefix {
                    __r.swift_prefix = v;
                }
                if let ::core::option::Option::Some(v) = __f_php_class_prefix {
                    __r.php_class_prefix = v;
                }
                if let ::core::option::Option::Some(v) = __f_php_namespace {
                    __r.php_namespace = v;
                }
                if let ::core::option::Option::Some(v) = __f_php_metadata_namespace {
                    __r.php_metadata_namespace = v;
                }
                if let ::core::option::Option::Some(v) = __f_ruby_package {
                    __r.ruby_package = v;
                }
                if let ::core::option::Option::Some(v) = __f_features {
                    __r.features = v;
                }
                if let ::core::option::Option::Some(v) = __f_uninterpreted_option {
                    __r.uninterpreted_option = v;
                }
                for __rec in __ext_records {
                    __r.__buffa_unknown_fields.push(__rec);
                }
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for FileOptions {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
#[derive(Clone, Debug, Default, PartialEq)]
#[repr(transparent)]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct __FileOptionsExtJson(pub ::buffa::UnknownFields);
impl ::core::ops::Deref for __FileOptionsExtJson {
    type Target = ::buffa::UnknownFields;
    fn deref(&self) -> &::buffa::UnknownFields {
        &self.0
    }
}
impl ::core::ops::DerefMut for __FileOptionsExtJson {
    fn deref_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.0
    }
}
impl ::core::convert::From<::buffa::UnknownFields> for __FileOptionsExtJson {
    fn from(u: ::buffa::UnknownFields) -> Self {
        Self(u)
    }
}
#[cfg(feature = "json")]
impl ::serde::Serialize for __FileOptionsExtJson {
    fn serialize<S: ::serde::Serializer>(
        &self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::buffa::extension_registry::serialize_extensions(
            "google.protobuf.FileOptions",
            &self.0,
            s,
        )
    }
}
#[cfg(feature = "json")]
impl<'de> ::serde::Deserialize<'de> for __FileOptionsExtJson {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        ::buffa::extension_registry::deserialize_extensions(
                "google.protobuf.FileOptions",
                d,
            )
            .map(Self)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __FILE_OPTIONS_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.FileOptions",
    to_json: ::buffa::type_registry::any_to_json::<FileOptions>,
    from_json: ::buffa::type_registry::any_from_json::<FileOptions>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __FILE_OPTIONS_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.FileOptions",
    text_encode: ::buffa::type_registry::any_encode_text::<FileOptions>,
    text_merge: ::buffa::type_registry::any_merge_text::<FileOptions>,
};
pub mod file_options {
    #[allow(unused_imports)]
    use super::*;
    /// Generated classes can be optimized for speed or code size.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    #[repr(i32)]
    pub enum OptimizeMode {
        /// Generate complete code for parsing, serialization,
        SPEED = 1i32,
        /// etc.
        ///
        /// Use ReflectionOps to implement these methods.
        CODE_SIZE = 2i32,
        /// Generate code using MessageLite and the lite runtime.
        LITE_RUNTIME = 3i32,
    }
    impl OptimizeMode {
        ///Idiomatic alias for [`Self::SPEED`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Speed: Self = Self::SPEED;
        ///Idiomatic alias for [`Self::CODE_SIZE`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const CodeSize: Self = Self::CODE_SIZE;
        ///Idiomatic alias for [`Self::LITE_RUNTIME`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const LiteRuntime: Self = Self::LITE_RUNTIME;
    }
    impl ::core::default::Default for OptimizeMode {
        fn default() -> Self {
            Self::SPEED
        }
    }
    #[cfg(feature = "json")]
    const _: () = {
        impl ::serde::Serialize for OptimizeMode {
            fn serialize<S: ::serde::Serializer>(
                &self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                s.serialize_str(::buffa::Enumeration::proto_name(self))
            }
        }
        impl<'de> ::serde::Deserialize<'de> for OptimizeMode {
            fn deserialize<D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                struct _V;
                impl ::serde::de::Visitor<'_> for _V {
                    type Value = OptimizeMode;
                    fn expecting(
                        &self,
                        f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        f.write_str(
                            concat!(
                                "a string, integer, or null for ", stringify!(OptimizeMode)
                            ),
                        )
                    }
                    fn visit_str<E: ::serde::de::Error>(
                        self,
                        v: &str,
                    ) -> ::core::result::Result<OptimizeMode, E> {
                        <OptimizeMode as ::buffa::Enumeration>::from_proto_name(v)
                            .ok_or_else(|| {
                                ::serde::de::Error::unknown_variant(v, &[])
                            })
                    }
                    fn visit_i64<E: ::serde::de::Error>(
                        self,
                        v: i64,
                    ) -> ::core::result::Result<OptimizeMode, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <OptimizeMode as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_u64<E: ::serde::de::Error>(
                        self,
                        v: u64,
                    ) -> ::core::result::Result<OptimizeMode, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <OptimizeMode as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_unit<E: ::serde::de::Error>(
                        self,
                    ) -> ::core::result::Result<OptimizeMode, E> {
                        ::core::result::Result::Ok(::core::default::Default::default())
                    }
                }
                d.deserialize_any(_V)
            }
        }
        impl ::buffa::json_helpers::ProtoElemJson for OptimizeMode {
            fn serialize_proto_json<S: ::serde::Serializer>(
                v: &Self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                ::serde::Serialize::serialize(v, s)
            }
            fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                <Self as ::serde::Deserialize>::deserialize(d)
            }
        }
    };
    impl ::buffa::Enumeration for OptimizeMode {
        fn from_i32(value: i32) -> ::core::option::Option<Self> {
            match value {
                1i32 => ::core::option::Option::Some(Self::SPEED),
                2i32 => ::core::option::Option::Some(Self::CODE_SIZE),
                3i32 => ::core::option::Option::Some(Self::LITE_RUNTIME),
                _ => ::core::option::Option::None,
            }
        }
        fn to_i32(&self) -> i32 {
            *self as i32
        }
        fn proto_name(&self) -> &'static str {
            match self {
                Self::SPEED => "SPEED",
                Self::CODE_SIZE => "CODE_SIZE",
                Self::LITE_RUNTIME => "LITE_RUNTIME",
            }
        }
        fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
            match name {
                "SPEED" => ::core::option::Option::Some(Self::SPEED),
                "CODE_SIZE" => ::core::option::Option::Some(Self::CODE_SIZE),
                "LITE_RUNTIME" => ::core::option::Option::Some(Self::LITE_RUNTIME),
                _ => ::core::option::Option::None,
            }
        }
        fn values() -> &'static [Self] {
            &[Self::SPEED, Self::CODE_SIZE, Self::LITE_RUNTIME]
        }
    }
}
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct MessageOptions {
    /// Set true to use the old proto1 MessageSet wire format for extensions.
    /// This is provided for backwards-compatibility with the MessageSet wire
    /// format.  You should not use this for any other reason:  It's less
    /// efficient, has fewer features, and is more complicated.
    ///
    /// The message must be defined exactly as follows:
    ///   message Foo {
    /// ```text
    /// option message_set_wire_format = true;
    /// extensions 4 to max;
    /// ```
    ///   }
    /// Note that the message cannot have any defined fields; MessageSets only
    /// have extensions.
    ///
    /// All extensions of your type must be singular messages; e.g. they cannot
    /// be int32s, enums, or repeated messages.
    ///
    /// Because this is an option, the above two restrictions are not enforced by
    /// the protocol compiler.
    ///
    /// Field 1: `message_set_wire_format`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "messageSetWireFormat",
            alias = "message_set_wire_format",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub message_set_wire_format: ::core::option::Option<bool>,
    /// Disables the generation of the standard "descriptor()" accessor, which can
    /// conflict with a field of the same name.  This is meant to make migration
    /// from proto1 easier; new code should avoid fields named "descriptor".
    ///
    /// Field 2: `no_standard_descriptor_accessor`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "noStandardDescriptorAccessor",
            alias = "no_standard_descriptor_accessor",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub no_standard_descriptor_accessor: ::core::option::Option<bool>,
    /// Is this message deprecated?
    /// Depending on the target platform, this can emit Deprecated annotations
    /// for the message, or it will be completely ignored; in the very least,
    /// this is a formalization for deprecating messages.
    ///
    /// Field 3: `deprecated`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "deprecated",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub deprecated: ::core::option::Option<bool>,
    /// Whether the message is an automatically generated map entry type for the
    /// maps field.
    ///
    /// For maps fields:
    /// ```text
    /// map<KeyType, ValueType> map_field = 1;
    /// ```
    /// The parsed descriptor looks like:
    /// ```text
    /// message MapFieldEntry {
    ///     option map_entry = true;
    ///     optional KeyType key = 1;
    ///     optional ValueType value = 2;
    /// }
    /// repeated MapFieldEntry map_field = 1;
    /// ```
    ///
    /// Implementations may choose not to generate the map_entry=true message, but
    /// use a native map in the target language to hold the keys and values.
    /// The reflection APIs in such implementations still need to work as
    /// if the field is a repeated message field.
    ///
    /// NOTE: Do not set the option in .proto files. Always use the maps syntax
    /// instead. The option should only be implicitly set by the proto compiler
    /// parser.
    ///
    /// Field 7: `map_entry`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "mapEntry",
            alias = "map_entry",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub map_entry: ::core::option::Option<bool>,
    /// Enable the legacy handling of JSON field name conflicts.  This lowercases
    /// and strips underscored from the fields before comparison in proto3 only.
    /// The new behavior takes `json_name` into account and applies to proto2 as
    /// well.
    ///
    /// This should only be used as a temporary measure against broken builds due
    /// to the change in behavior for JSON field name conflicts.
    ///
    /// TODO This is legacy behavior we plan to remove once downstream
    /// teams have had time to migrate.
    ///
    /// Field 11: `deprecated_legacy_json_field_conflicts`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "deprecatedLegacyJsonFieldConflicts",
            alias = "deprecated_legacy_json_field_conflicts",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub deprecated_legacy_json_field_conflicts: ::core::option::Option<bool>,
    /// Any features defined in the specific edition.
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    ///
    /// Field 12: `features`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "features",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub features: ::buffa::MessageField<FeatureSet, ::buffa::Inline<FeatureSet>>,
    /// The parser stores options it doesn't recognize here. See above.
    ///
    /// Field 999: `uninterpreted_option`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "uninterpretedOption",
            alias = "uninterpreted_option",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub uninterpreted_option: ::buffa::alloc::vec::Vec<UninterpretedOption>,
    #[cfg_attr(feature = "json", serde(flatten))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: __MessageOptionsExtJson,
}
impl ::core::fmt::Debug for MessageOptions {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("MessageOptions")
            .field("message_set_wire_format", &self.message_set_wire_format)
            .field(
                "no_standard_descriptor_accessor",
                &self.no_standard_descriptor_accessor,
            )
            .field("deprecated", &self.deprecated)
            .field("map_entry", &self.map_entry)
            .field(
                "deprecated_legacy_json_field_conflicts",
                &self.deprecated_legacy_json_field_conflicts,
            )
            .field("features", &self.features)
            .field("uninterpreted_option", &self.uninterpreted_option)
            .finish()
    }
}
impl MessageOptions {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.MessageOptions";
}
impl MessageOptions {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::message_set_wire_format`] to `Some(value)`, consuming and returning `self`.
    pub fn with_message_set_wire_format(mut self, value: bool) -> Self {
        self.message_set_wire_format = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::no_standard_descriptor_accessor`] to `Some(value)`, consuming and returning `self`.
    pub fn with_no_standard_descriptor_accessor(mut self, value: bool) -> Self {
        self.no_standard_descriptor_accessor = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::deprecated`] to `Some(value)`, consuming and returning `self`.
    pub fn with_deprecated(mut self, value: bool) -> Self {
        self.deprecated = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::map_entry`] to `Some(value)`, consuming and returning `self`.
    pub fn with_map_entry(mut self, value: bool) -> Self {
        self.map_entry = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::deprecated_legacy_json_field_conflicts`] to `Some(value)`, consuming and returning `self`.
    pub fn with_deprecated_legacy_json_field_conflicts(mut self, value: bool) -> Self {
        self.deprecated_legacy_json_field_conflicts = Some(value);
        self
    }
}
::buffa::impl_default_instance!(MessageOptions);
impl ::buffa::MessageName for MessageOptions {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "MessageOptions";
    const FULL_NAME: &'static str = "google.protobuf.MessageOptions";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.MessageOptions";
}
impl ::buffa::Message for MessageOptions {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if self.message_set_wire_format.is_some() {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.no_standard_descriptor_accessor.is_some() {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.deprecated.is_some() {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.map_entry.is_some() {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.deprecated_legacy_json_field_conflicts.is_some() {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.features.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.features.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.uninterpreted_option {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 2u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let Some(v) = self.message_set_wire_format {
            ::buffa::types::put_bool_field(1u32, v, buf);
        }
        if let Some(v) = self.no_standard_descriptor_accessor {
            ::buffa::types::put_bool_field(2u32, v, buf);
        }
        if let Some(v) = self.deprecated {
            ::buffa::types::put_bool_field(3u32, v, buf);
        }
        if let Some(v) = self.map_entry {
            ::buffa::types::put_bool_field(7u32, v, buf);
        }
        if let Some(v) = self.deprecated_legacy_json_field_conflicts {
            ::buffa::types::put_bool_field(11u32, v, buf);
        }
        if self.features.is_set() {
            ::buffa::types::put_len_delimited_header(
                12u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.features.write_to(__cache, buf);
        }
        for v in &self.uninterpreted_option {
            ::buffa::types::put_len_delimited_header(
                999u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.message_set_wire_format = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.no_standard_descriptor_accessor = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.deprecated = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.map_entry = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            11u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.deprecated_legacy_json_field_conflicts = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            12u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.features.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            999u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.uninterpreted_option.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.message_set_wire_format = ::core::option::Option::None;
        self.no_standard_descriptor_accessor = ::core::option::Option::None;
        self.deprecated = ::core::option::Option::None;
        self.map_entry = ::core::option::Option::None;
        self.deprecated_legacy_json_field_conflicts = ::core::option::Option::None;
        self.features = ::buffa::MessageField::none();
        self.uninterpreted_option.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for MessageOptions {
    const PROTO_FQN: &'static str = "google.protobuf.MessageOptions";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for MessageOptions {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref __v) = self.message_set_wire_format {
            enc.write_field_name("message_set_wire_format")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self
            .no_standard_descriptor_accessor
        {
            enc.write_field_name("no_standard_descriptor_accessor")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.deprecated {
            enc.write_field_name("deprecated")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.map_entry {
            enc.write_field_name("map_entry")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self
            .deprecated_legacy_json_field_conflicts
        {
            enc.write_field_name("deprecated_legacy_json_field_conflicts")?;
            enc.write_bool(*__v)?;
        }
        if self.features.is_set() {
            enc.write_field_name("features")?;
            enc.write_message(&*self.features)?;
        }
        for __v in &self.uninterpreted_option {
            enc.write_field_name("uninterpreted_option")?;
            enc.write_message(__v)?;
        }
        enc.write_extension_fields(
            "google.protobuf.MessageOptions",
            &self.__buffa_unknown_fields,
        )?;
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "message_set_wire_format" => {
                    self.message_set_wire_format = ::core::option::Option::Some(
                        dec.read_bool()?,
                    );
                }
                "no_standard_descriptor_accessor" => {
                    self.no_standard_descriptor_accessor = ::core::option::Option::Some(
                        dec.read_bool()?,
                    );
                }
                "deprecated" => {
                    self.deprecated = ::core::option::Option::Some(dec.read_bool()?);
                }
                "map_entry" => {
                    self.map_entry = ::core::option::Option::Some(dec.read_bool()?);
                }
                "deprecated_legacy_json_field_conflicts" => {
                    self.deprecated_legacy_json_field_conflicts = ::core::option::Option::Some(
                        dec.read_bool()?,
                    );
                }
                "features" => dec.merge_message(self.features.get_or_insert_default())?,
                "uninterpreted_option" => {
                    dec.read_repeated_into(
                        &mut self.uninterpreted_option,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                __name if __name.starts_with('[') => {
                    for __r in dec
                        .read_extension(__name, "google.protobuf.MessageOptions")?
                    {
                        self.__buffa_unknown_fields.push(__r);
                    }
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl<'de> serde::Deserialize<'de> for MessageOptions {
    fn deserialize<D: serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl<'de> serde::de::Visitor<'de> for _V {
            type Value = MessageOptions;
            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                f.write_str("struct MessageOptions")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<MessageOptions, A::Error> {
                let mut __f_message_set_wire_format: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_no_standard_descriptor_accessor: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_deprecated: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_map_entry: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_deprecated_legacy_json_field_conflicts: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_features: ::core::option::Option<
                    ::buffa::MessageField<FeatureSet, ::buffa::Inline<FeatureSet>>,
                > = None;
                let mut __f_uninterpreted_option: ::core::option::Option<
                    ::buffa::alloc::vec::Vec<UninterpretedOption>,
                > = None;
                let mut __ext_records: ::buffa::alloc::vec::Vec<::buffa::UnknownField> = ::buffa::alloc::vec::Vec::new();
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "messageSetWireFormat" | "message_set_wire_format" => {
                            __f_message_set_wire_format = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "noStandardDescriptorAccessor"
                        | "no_standard_descriptor_accessor" => {
                            __f_no_standard_descriptor_accessor = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "deprecated" => {
                            __f_deprecated = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "mapEntry" | "map_entry" => {
                            __f_map_entry = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "deprecatedLegacyJsonFieldConflicts"
                        | "deprecated_legacy_json_field_conflicts" => {
                            __f_deprecated_legacy_json_field_conflicts = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "features" => {
                            __f_features = Some(
                                map
                                    .next_value::<
                                        ::buffa::MessageField<
                                            FeatureSet,
                                            ::buffa::Inline<FeatureSet>,
                                        >,
                                    >()?,
                            );
                        }
                        "uninterpretedOption" | "uninterpreted_option" => {
                            __f_uninterpreted_option = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::buffa::alloc::vec::Vec<UninterpretedOption>;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::buffa::alloc::vec::Vec<UninterpretedOption>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::null_as_default(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        __k if __k.starts_with('[') => {
                            let __v: ::buffa::serde_json::Value = map.next_value()?;
                            match ::buffa::extension_registry::deserialize_extension_key(
                                "google.protobuf.MessageOptions",
                                __k,
                                __v,
                            ) {
                                ::core::option::Option::Some(
                                    ::core::result::Result::Ok(__recs),
                                ) => {
                                    for __rec in __recs {
                                        __ext_records.push(__rec);
                                    }
                                }
                                ::core::option::Option::Some(
                                    ::core::result::Result::Err(__e),
                                ) => {
                                    return ::core::result::Result::Err(
                                        <A::Error as ::serde::de::Error>::custom(__e),
                                    );
                                }
                                ::core::option::Option::None => {}
                            }
                        }
                        _ => {
                            map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                let mut __r = <MessageOptions as ::core::default::Default>::default();
                if let ::core::option::Option::Some(v) = __f_message_set_wire_format {
                    __r.message_set_wire_format = v;
                }
                if let ::core::option::Option::Some(v) = __f_no_standard_descriptor_accessor {
                    __r.no_standard_descriptor_accessor = v;
                }
                if let ::core::option::Option::Some(v) = __f_deprecated {
                    __r.deprecated = v;
                }
                if let ::core::option::Option::Some(v) = __f_map_entry {
                    __r.map_entry = v;
                }
                if let ::core::option::Option::Some(v) = __f_deprecated_legacy_json_field_conflicts {
                    __r.deprecated_legacy_json_field_conflicts = v;
                }
                if let ::core::option::Option::Some(v) = __f_features {
                    __r.features = v;
                }
                if let ::core::option::Option::Some(v) = __f_uninterpreted_option {
                    __r.uninterpreted_option = v;
                }
                for __rec in __ext_records {
                    __r.__buffa_unknown_fields.push(__rec);
                }
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for MessageOptions {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
#[derive(Clone, Debug, Default, PartialEq)]
#[repr(transparent)]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct __MessageOptionsExtJson(pub ::buffa::UnknownFields);
impl ::core::ops::Deref for __MessageOptionsExtJson {
    type Target = ::buffa::UnknownFields;
    fn deref(&self) -> &::buffa::UnknownFields {
        &self.0
    }
}
impl ::core::ops::DerefMut for __MessageOptionsExtJson {
    fn deref_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.0
    }
}
impl ::core::convert::From<::buffa::UnknownFields> for __MessageOptionsExtJson {
    fn from(u: ::buffa::UnknownFields) -> Self {
        Self(u)
    }
}
#[cfg(feature = "json")]
impl ::serde::Serialize for __MessageOptionsExtJson {
    fn serialize<S: ::serde::Serializer>(
        &self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::buffa::extension_registry::serialize_extensions(
            "google.protobuf.MessageOptions",
            &self.0,
            s,
        )
    }
}
#[cfg(feature = "json")]
impl<'de> ::serde::Deserialize<'de> for __MessageOptionsExtJson {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        ::buffa::extension_registry::deserialize_extensions(
                "google.protobuf.MessageOptions",
                d,
            )
            .map(Self)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __MESSAGE_OPTIONS_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.MessageOptions",
    to_json: ::buffa::type_registry::any_to_json::<MessageOptions>,
    from_json: ::buffa::type_registry::any_from_json::<MessageOptions>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __MESSAGE_OPTIONS_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.MessageOptions",
    text_encode: ::buffa::type_registry::any_encode_text::<MessageOptions>,
    text_merge: ::buffa::type_registry::any_merge_text::<MessageOptions>,
};
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct FieldOptions {
    /// NOTE: ctype is deprecated. Use `features.(pb.cpp).string_type` instead.
    /// The ctype option instructs the C++ code generator to use a different
    /// representation of the field than it normally would.  See the specific
    /// options below.  This option is only implemented to support use of
    /// \[ctype=CORD\] and \[ctype=STRING\] (the default) on non-repeated fields of
    /// type "bytes" in the open source release.
    /// TODO: make ctype actually deprecated.
    ///
    /// Field 1: `ctype`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "ctype",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub ctype: ::core::option::Option<field_options::CType>,
    /// The packed option can be enabled for repeated primitive fields to enable
    /// a more efficient representation on the wire. Rather than repeatedly
    /// writing the tag and type for each element, the entire array is encoded as
    /// a single length-delimited blob. In proto3, only explicit setting it to
    /// false will avoid using packed encoding.  This option is prohibited in
    /// Editions, but the `repeated_field_encoding` feature can be used to control
    /// the behavior.
    ///
    /// Field 2: `packed`
    #[cfg_attr(
        feature = "json",
        serde(rename = "packed", skip_serializing_if = "::core::option::Option::is_none")
    )]
    pub packed: ::core::option::Option<bool>,
    /// The jstype option determines the JavaScript type used for values of the
    /// field.  The option is permitted only for 64 bit integral and fixed types
    /// (int64, uint64, sint64, fixed64, sfixed64).  A field with jstype JS_STRING
    /// is represented as JavaScript string, which avoids loss of precision that
    /// can happen when a large value is converted to a floating point JavaScript.
    /// Specifying JS_NUMBER for the jstype causes the generated JavaScript code to
    /// use the JavaScript "number" type.  The behavior of the default option
    /// JS_NORMAL is implementation dependent.
    ///
    /// This option is an enum to permit additional types to be added, e.g.
    /// goog.math.Integer.
    ///
    /// Field 6: `jstype`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "jstype",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub jstype: ::core::option::Option<field_options::JSType>,
    /// Should this field be parsed lazily?  Lazy applies only to message-type
    /// fields.  It means that when the outer message is initially parsed, the
    /// inner message's contents will not be parsed but instead stored in encoded
    /// form.  The inner message will actually be parsed when it is first accessed.
    ///
    /// This is only a hint.  Implementations are free to choose whether to use
    /// eager or lazy parsing regardless of the value of this option.  However,
    /// setting this option true suggests that the protocol author believes that
    /// using lazy parsing on this field is worth the additional bookkeeping
    /// overhead typically needed to implement it.
    ///
    /// This option does not affect the public interface of any generated code;
    /// all method signatures remain the same.  Furthermore, thread-safety of the
    /// interface is not affected by this option; const methods remain safe to
    /// call from multiple threads concurrently, while non-const methods continue
    /// to require exclusive access.
    ///
    /// Note that lazy message fields are still eagerly verified to check
    /// ill-formed wireformat or missing required fields. Calling IsInitialized()
    /// on the outer message would fail if the inner message has missing required
    /// fields. Failed verification would result in parsing failure (except when
    /// uninitialized messages are acceptable).
    ///
    /// Field 5: `lazy`
    #[cfg_attr(
        feature = "json",
        serde(rename = "lazy", skip_serializing_if = "::core::option::Option::is_none")
    )]
    pub lazy: ::core::option::Option<bool>,
    /// unverified_lazy does no correctness checks on the byte stream. This should
    /// only be used where lazy with verification is prohibitive for performance
    /// reasons.
    ///
    /// Field 15: `unverified_lazy`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "unverifiedLazy",
            alias = "unverified_lazy",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub unverified_lazy: ::core::option::Option<bool>,
    /// Is this field deprecated?
    /// Depending on the target platform, this can emit Deprecated annotations
    /// for accessors, or it will be completely ignored; in the very least, this
    /// is a formalization for deprecating fields.
    ///
    /// Field 3: `deprecated`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "deprecated",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub deprecated: ::core::option::Option<bool>,
    /// DEPRECATED. DO NOT USE!
    /// For Google-internal migration only. Do not use.
    ///
    /// Field 10: `weak`
    #[cfg_attr(
        feature = "json",
        serde(rename = "weak", skip_serializing_if = "::core::option::Option::is_none")
    )]
    pub weak: ::core::option::Option<bool>,
    /// Indicate that the field value should not be printed out when using debug
    /// formats, e.g. when the field contains sensitive credentials.
    ///
    /// Field 16: `debug_redact`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "debugRedact",
            alias = "debug_redact",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub debug_redact: ::core::option::Option<bool>,
    /// Field 17: `retention`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "retention",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub retention: ::core::option::Option<field_options::OptionRetention>,
    /// Field 19: `targets`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "targets",
            with = "::buffa::json_helpers::repeated_closed_enum",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
        )
    )]
    pub targets: ::buffa::alloc::vec::Vec<field_options::OptionTargetType>,
    /// Field 20: `edition_defaults`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "editionDefaults",
            alias = "edition_defaults",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub edition_defaults: ::buffa::alloc::vec::Vec<field_options::EditionDefault>,
    /// Any features defined in the specific edition.
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    ///
    /// Field 21: `features`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "features",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub features: ::buffa::MessageField<FeatureSet, ::buffa::Inline<FeatureSet>>,
    /// Field 22: `feature_support`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "featureSupport",
            alias = "feature_support",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub feature_support: ::buffa::MessageField<
        field_options::FeatureSupport,
        ::buffa::Inline<field_options::FeatureSupport>,
    >,
    /// The parser stores options it doesn't recognize here. See above.
    ///
    /// Field 999: `uninterpreted_option`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "uninterpretedOption",
            alias = "uninterpreted_option",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub uninterpreted_option: ::buffa::alloc::vec::Vec<UninterpretedOption>,
    #[cfg_attr(feature = "json", serde(flatten))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: __FieldOptionsExtJson,
}
impl ::core::fmt::Debug for FieldOptions {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("FieldOptions")
            .field("ctype", &self.ctype)
            .field("packed", &self.packed)
            .field("jstype", &self.jstype)
            .field("lazy", &self.lazy)
            .field("unverified_lazy", &self.unverified_lazy)
            .field("deprecated", &self.deprecated)
            .field("weak", &self.weak)
            .field("debug_redact", &self.debug_redact)
            .field("retention", &self.retention)
            .field("targets", &self.targets)
            .field("edition_defaults", &self.edition_defaults)
            .field("features", &self.features)
            .field("feature_support", &self.feature_support)
            .field("uninterpreted_option", &self.uninterpreted_option)
            .finish()
    }
}
impl FieldOptions {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FieldOptions";
}
impl FieldOptions {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::ctype`] to `Some(value)`, consuming and returning `self`.
    pub fn with_ctype(mut self, value: impl Into<field_options::CType>) -> Self {
        self.ctype = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::packed`] to `Some(value)`, consuming and returning `self`.
    pub fn with_packed(mut self, value: bool) -> Self {
        self.packed = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::jstype`] to `Some(value)`, consuming and returning `self`.
    pub fn with_jstype(mut self, value: impl Into<field_options::JSType>) -> Self {
        self.jstype = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::lazy`] to `Some(value)`, consuming and returning `self`.
    pub fn with_lazy(mut self, value: bool) -> Self {
        self.lazy = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::unverified_lazy`] to `Some(value)`, consuming and returning `self`.
    pub fn with_unverified_lazy(mut self, value: bool) -> Self {
        self.unverified_lazy = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::deprecated`] to `Some(value)`, consuming and returning `self`.
    pub fn with_deprecated(mut self, value: bool) -> Self {
        self.deprecated = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::weak`] to `Some(value)`, consuming and returning `self`.
    pub fn with_weak(mut self, value: bool) -> Self {
        self.weak = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::debug_redact`] to `Some(value)`, consuming and returning `self`.
    pub fn with_debug_redact(mut self, value: bool) -> Self {
        self.debug_redact = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::retention`] to `Some(value)`, consuming and returning `self`.
    pub fn with_retention(
        mut self,
        value: impl Into<field_options::OptionRetention>,
    ) -> Self {
        self.retention = Some(value.into());
        self
    }
}
::buffa::impl_default_instance!(FieldOptions);
impl ::buffa::MessageName for FieldOptions {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "FieldOptions";
    const FULL_NAME: &'static str = "google.protobuf.FieldOptions";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FieldOptions";
}
impl ::buffa::Message for FieldOptions {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if let Some(ref v) = self.ctype {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        if self.packed.is_some() {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.deprecated.is_some() {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.lazy.is_some() {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if let Some(ref v) = self.jstype {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        if self.weak.is_some() {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.unverified_lazy.is_some() {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.debug_redact.is_some() {
            size += 2u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if let Some(ref v) = self.retention {
            size += 2u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        for v in &self.targets {
            size += 2u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        for v in &self.edition_defaults {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 2u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if self.features.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.features.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 2u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if self.feature_support.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.feature_support.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 2u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.uninterpreted_option {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 2u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let Some(ref v) = self.ctype {
            ::buffa::types::put_int32_field(1u32, v.to_i32(), buf);
        }
        if let Some(v) = self.packed {
            ::buffa::types::put_bool_field(2u32, v, buf);
        }
        if let Some(v) = self.deprecated {
            ::buffa::types::put_bool_field(3u32, v, buf);
        }
        if let Some(v) = self.lazy {
            ::buffa::types::put_bool_field(5u32, v, buf);
        }
        if let Some(ref v) = self.jstype {
            ::buffa::types::put_int32_field(6u32, v.to_i32(), buf);
        }
        if let Some(v) = self.weak {
            ::buffa::types::put_bool_field(10u32, v, buf);
        }
        if let Some(v) = self.unverified_lazy {
            ::buffa::types::put_bool_field(15u32, v, buf);
        }
        if let Some(v) = self.debug_redact {
            ::buffa::types::put_bool_field(16u32, v, buf);
        }
        if let Some(ref v) = self.retention {
            ::buffa::types::put_int32_field(17u32, v.to_i32(), buf);
        }
        for v in &self.targets {
            ::buffa::types::put_int32_field(19u32, v.to_i32(), buf);
        }
        for v in &self.edition_defaults {
            ::buffa::types::put_len_delimited_header(
                20u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        if self.features.is_set() {
            ::buffa::types::put_len_delimited_header(
                21u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.features.write_to(__cache, buf);
        }
        if self.feature_support.is_set() {
            ::buffa::types::put_len_delimited_header(
                22u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.feature_support.write_to(__cache, buf);
        }
        for v in &self.uninterpreted_option {
            ::buffa::types::put_len_delimited_header(
                999u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.ctype = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 1u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.packed = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.deprecated = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.lazy = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.jstype = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 6u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            10u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.weak = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            15u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.unverified_lazy = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            16u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.debug_redact = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            17u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.retention = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 17u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            19u32 => {
                if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
                    let len = ::buffa::encoding::decode_varint(buf)?;
                    let len = usize::try_from(len)
                        .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
                    if buf.remaining() < len {
                        return ::core::result::Result::Err(
                            ::buffa::DecodeError::UnexpectedEof,
                        );
                    }
                    self.targets.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        let __raw = ::buffa::types::decode_int32(&mut limited)?;
                        if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                            __raw,
                        ) {
                            self.targets.push(__v);
                        } else {
                            ctx.register_unknown_field()?;
                            self.__buffa_unknown_fields
                                .push(::buffa::UnknownField {
                                    number: 19u32,
                                    data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                                });
                        }
                    }
                    let leftover = limited.remaining();
                    if leftover > 0 {
                        limited.advance(leftover);
                    }
                } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
                    let __raw = ::buffa::types::decode_int32(buf)?;
                    if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                        __raw,
                    ) {
                        self.targets.push(__v);
                    } else {
                        ctx.register_unknown_field()?;
                        self.__buffa_unknown_fields
                            .push(::buffa::UnknownField {
                                number: 19u32,
                                data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                            });
                    }
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            20u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.edition_defaults.push(elem);
            }
            21u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.features.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            22u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.feature_support.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            999u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.uninterpreted_option.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.ctype = ::core::option::Option::None;
        self.packed = ::core::option::Option::None;
        self.deprecated = ::core::option::Option::None;
        self.lazy = ::core::option::Option::None;
        self.jstype = ::core::option::Option::None;
        self.weak = ::core::option::Option::None;
        self.unverified_lazy = ::core::option::Option::None;
        self.debug_redact = ::core::option::Option::None;
        self.retention = ::core::option::Option::None;
        self.targets.clear();
        self.edition_defaults.clear();
        self.features = ::buffa::MessageField::none();
        self.feature_support = ::buffa::MessageField::none();
        self.uninterpreted_option.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for FieldOptions {
    const PROTO_FQN: &'static str = "google.protobuf.FieldOptions";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for FieldOptions {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref __v) = self.ctype {
            enc.write_field_name("ctype")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        if let ::core::option::Option::Some(ref __v) = self.packed {
            enc.write_field_name("packed")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.jstype {
            enc.write_field_name("jstype")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        if let ::core::option::Option::Some(ref __v) = self.lazy {
            enc.write_field_name("lazy")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.unverified_lazy {
            enc.write_field_name("unverified_lazy")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.deprecated {
            enc.write_field_name("deprecated")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.weak {
            enc.write_field_name("weak")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.debug_redact {
            enc.write_field_name("debug_redact")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.retention {
            enc.write_field_name("retention")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        if self.features.is_set() {
            enc.write_field_name("features")?;
            enc.write_message(&*self.features)?;
        }
        if self.feature_support.is_set() {
            enc.write_field_name("feature_support")?;
            enc.write_message(&*self.feature_support)?;
        }
        for __v in &self.targets {
            enc.write_field_name("targets")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        for __v in &self.edition_defaults {
            enc.write_field_name("edition_defaults")?;
            enc.write_message(__v)?;
        }
        for __v in &self.uninterpreted_option {
            enc.write_field_name("uninterpreted_option")?;
            enc.write_message(__v)?;
        }
        enc.write_extension_fields(
            "google.protobuf.FieldOptions",
            &self.__buffa_unknown_fields,
        )?;
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "ctype" => {
                    self.ctype = ::core::option::Option::Some(
                        dec.read_closed_enum_by_name::<field_options::CType>()?,
                    );
                }
                "packed" => self.packed = ::core::option::Option::Some(dec.read_bool()?),
                "jstype" => {
                    self.jstype = ::core::option::Option::Some(
                        dec.read_closed_enum_by_name::<field_options::JSType>()?,
                    );
                }
                "lazy" => self.lazy = ::core::option::Option::Some(dec.read_bool()?),
                "unverified_lazy" => {
                    self.unverified_lazy = ::core::option::Option::Some(dec.read_bool()?);
                }
                "deprecated" => {
                    self.deprecated = ::core::option::Option::Some(dec.read_bool()?);
                }
                "weak" => self.weak = ::core::option::Option::Some(dec.read_bool()?),
                "debug_redact" => {
                    self.debug_redact = ::core::option::Option::Some(dec.read_bool()?);
                }
                "retention" => {
                    self.retention = ::core::option::Option::Some(
                        dec.read_closed_enum_by_name::<field_options::OptionRetention>()?,
                    );
                }
                "features" => dec.merge_message(self.features.get_or_insert_default())?,
                "feature_support" => {
                    dec.merge_message(self.feature_support.get_or_insert_default())?
                }
                "targets" => {
                    dec.read_repeated_into(
                        &mut self.targets,
                        |__d| {
                            __d
                                .read_closed_enum_by_name::<
                                    field_options::OptionTargetType,
                                >()
                        },
                    )?
                }
                "edition_defaults" => {
                    dec.read_repeated_into(
                        &mut self.edition_defaults,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                "uninterpreted_option" => {
                    dec.read_repeated_into(
                        &mut self.uninterpreted_option,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                __name if __name.starts_with('[') => {
                    for __r in dec
                        .read_extension(__name, "google.protobuf.FieldOptions")?
                    {
                        self.__buffa_unknown_fields.push(__r);
                    }
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl<'de> serde::Deserialize<'de> for FieldOptions {
    fn deserialize<D: serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl<'de> serde::de::Visitor<'de> for _V {
            type Value = FieldOptions;
            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                f.write_str("struct FieldOptions")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<FieldOptions, A::Error> {
                let mut __f_ctype: ::core::option::Option<
                    ::core::option::Option<field_options::CType>,
                > = None;
                let mut __f_packed: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_jstype: ::core::option::Option<
                    ::core::option::Option<field_options::JSType>,
                > = None;
                let mut __f_lazy: ::core::option::Option<::core::option::Option<bool>> = None;
                let mut __f_unverified_lazy: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_deprecated: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_weak: ::core::option::Option<::core::option::Option<bool>> = None;
                let mut __f_debug_redact: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_retention: ::core::option::Option<
                    ::core::option::Option<field_options::OptionRetention>,
                > = None;
                let mut __f_targets: ::core::option::Option<
                    ::buffa::alloc::vec::Vec<field_options::OptionTargetType>,
                > = None;
                let mut __f_edition_defaults: ::core::option::Option<
                    ::buffa::alloc::vec::Vec<field_options::EditionDefault>,
                > = None;
                let mut __f_features: ::core::option::Option<
                    ::buffa::MessageField<FeatureSet, ::buffa::Inline<FeatureSet>>,
                > = None;
                let mut __f_feature_support: ::core::option::Option<
                    ::buffa::MessageField<
                        field_options::FeatureSupport,
                        ::buffa::Inline<field_options::FeatureSupport>,
                    >,
                > = None;
                let mut __f_uninterpreted_option: ::core::option::Option<
                    ::buffa::alloc::vec::Vec<UninterpretedOption>,
                > = None;
                let mut __ext_records: ::buffa::alloc::vec::Vec<::buffa::UnknownField> = ::buffa::alloc::vec::Vec::new();
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "ctype" => {
                            __f_ctype = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::core::option::Option<field_options::CType>;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::core::option::Option<field_options::CType>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::opt_closed_enum::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "packed" => {
                            __f_packed = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "jstype" => {
                            __f_jstype = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::core::option::Option<field_options::JSType>;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::core::option::Option<field_options::JSType>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::opt_closed_enum::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "lazy" => {
                            __f_lazy = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "unverifiedLazy" | "unverified_lazy" => {
                            __f_unverified_lazy = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "deprecated" => {
                            __f_deprecated = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "weak" => {
                            __f_weak = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "debugRedact" | "debug_redact" => {
                            __f_debug_redact = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "retention" => {
                            __f_retention = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::core::option::Option<
                                        field_options::OptionRetention,
                                    >;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::core::option::Option<field_options::OptionRetention>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::opt_closed_enum::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "targets" => {
                            __f_targets = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::buffa::alloc::vec::Vec<
                                        field_options::OptionTargetType,
                                    >;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::buffa::alloc::vec::Vec<field_options::OptionTargetType>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::repeated_closed_enum::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "editionDefaults" | "edition_defaults" => {
                            __f_edition_defaults = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::buffa::alloc::vec::Vec<
                                        field_options::EditionDefault,
                                    >;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::buffa::alloc::vec::Vec<field_options::EditionDefault>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::null_as_default(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "features" => {
                            __f_features = Some(
                                map
                                    .next_value::<
                                        ::buffa::MessageField<
                                            FeatureSet,
                                            ::buffa::Inline<FeatureSet>,
                                        >,
                                    >()?,
                            );
                        }
                        "featureSupport" | "feature_support" => {
                            __f_feature_support = Some(
                                map
                                    .next_value::<
                                        ::buffa::MessageField<
                                            field_options::FeatureSupport,
                                            ::buffa::Inline<field_options::FeatureSupport>,
                                        >,
                                    >()?,
                            );
                        }
                        "uninterpretedOption" | "uninterpreted_option" => {
                            __f_uninterpreted_option = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::buffa::alloc::vec::Vec<UninterpretedOption>;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::buffa::alloc::vec::Vec<UninterpretedOption>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::null_as_default(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        __k if __k.starts_with('[') => {
                            let __v: ::buffa::serde_json::Value = map.next_value()?;
                            match ::buffa::extension_registry::deserialize_extension_key(
                                "google.protobuf.FieldOptions",
                                __k,
                                __v,
                            ) {
                                ::core::option::Option::Some(
                                    ::core::result::Result::Ok(__recs),
                                ) => {
                                    for __rec in __recs {
                                        __ext_records.push(__rec);
                                    }
                                }
                                ::core::option::Option::Some(
                                    ::core::result::Result::Err(__e),
                                ) => {
                                    return ::core::result::Result::Err(
                                        <A::Error as ::serde::de::Error>::custom(__e),
                                    );
                                }
                                ::core::option::Option::None => {}
                            }
                        }
                        _ => {
                            map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                let mut __r = <FieldOptions as ::core::default::Default>::default();
                if let ::core::option::Option::Some(v) = __f_ctype {
                    __r.ctype = v;
                }
                if let ::core::option::Option::Some(v) = __f_packed {
                    __r.packed = v;
                }
                if let ::core::option::Option::Some(v) = __f_jstype {
                    __r.jstype = v;
                }
                if let ::core::option::Option::Some(v) = __f_lazy {
                    __r.lazy = v;
                }
                if let ::core::option::Option::Some(v) = __f_unverified_lazy {
                    __r.unverified_lazy = v;
                }
                if let ::core::option::Option::Some(v) = __f_deprecated {
                    __r.deprecated = v;
                }
                if let ::core::option::Option::Some(v) = __f_weak {
                    __r.weak = v;
                }
                if let ::core::option::Option::Some(v) = __f_debug_redact {
                    __r.debug_redact = v;
                }
                if let ::core::option::Option::Some(v) = __f_retention {
                    __r.retention = v;
                }
                if let ::core::option::Option::Some(v) = __f_targets {
                    __r.targets = v;
                }
                if let ::core::option::Option::Some(v) = __f_edition_defaults {
                    __r.edition_defaults = v;
                }
                if let ::core::option::Option::Some(v) = __f_features {
                    __r.features = v;
                }
                if let ::core::option::Option::Some(v) = __f_feature_support {
                    __r.feature_support = v;
                }
                if let ::core::option::Option::Some(v) = __f_uninterpreted_option {
                    __r.uninterpreted_option = v;
                }
                for __rec in __ext_records {
                    __r.__buffa_unknown_fields.push(__rec);
                }
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for FieldOptions {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
#[derive(Clone, Debug, Default, PartialEq)]
#[repr(transparent)]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct __FieldOptionsExtJson(pub ::buffa::UnknownFields);
impl ::core::ops::Deref for __FieldOptionsExtJson {
    type Target = ::buffa::UnknownFields;
    fn deref(&self) -> &::buffa::UnknownFields {
        &self.0
    }
}
impl ::core::ops::DerefMut for __FieldOptionsExtJson {
    fn deref_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.0
    }
}
impl ::core::convert::From<::buffa::UnknownFields> for __FieldOptionsExtJson {
    fn from(u: ::buffa::UnknownFields) -> Self {
        Self(u)
    }
}
#[cfg(feature = "json")]
impl ::serde::Serialize for __FieldOptionsExtJson {
    fn serialize<S: ::serde::Serializer>(
        &self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::buffa::extension_registry::serialize_extensions(
            "google.protobuf.FieldOptions",
            &self.0,
            s,
        )
    }
}
#[cfg(feature = "json")]
impl<'de> ::serde::Deserialize<'de> for __FieldOptionsExtJson {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        ::buffa::extension_registry::deserialize_extensions(
                "google.protobuf.FieldOptions",
                d,
            )
            .map(Self)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __FIELD_OPTIONS_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.FieldOptions",
    to_json: ::buffa::type_registry::any_to_json::<FieldOptions>,
    from_json: ::buffa::type_registry::any_from_json::<FieldOptions>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __FIELD_OPTIONS_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.FieldOptions",
    text_encode: ::buffa::type_registry::any_encode_text::<FieldOptions>,
    text_merge: ::buffa::type_registry::any_merge_text::<FieldOptions>,
};
pub mod field_options {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    #[repr(i32)]
    pub enum CType {
        /// Default mode.
        STRING = 0i32,
        /// The option \[ctype=CORD\] may be applied to a non-repeated field of type
        /// "bytes". It indicates that in C++, the data should be stored in a Cord
        /// instead of a string.  For very large strings, this may reduce memory
        /// fragmentation. It may also allow better performance when parsing from a
        /// Cord, or when parsing with aliasing enabled, as the parsed Cord may then
        /// alias the original buffer.
        CORD = 1i32,
        STRING_PIECE = 2i32,
    }
    impl CType {
        ///Idiomatic alias for [`Self::STRING`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const String: Self = Self::STRING;
        ///Idiomatic alias for [`Self::CORD`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Cord: Self = Self::CORD;
        ///Idiomatic alias for [`Self::STRING_PIECE`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const StringPiece: Self = Self::STRING_PIECE;
    }
    impl ::core::default::Default for CType {
        fn default() -> Self {
            Self::STRING
        }
    }
    #[cfg(feature = "json")]
    const _: () = {
        impl ::serde::Serialize for CType {
            fn serialize<S: ::serde::Serializer>(
                &self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                s.serialize_str(::buffa::Enumeration::proto_name(self))
            }
        }
        impl<'de> ::serde::Deserialize<'de> for CType {
            fn deserialize<D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                struct _V;
                impl ::serde::de::Visitor<'_> for _V {
                    type Value = CType;
                    fn expecting(
                        &self,
                        f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        f.write_str(
                            concat!("a string, integer, or null for ", stringify!(CType)),
                        )
                    }
                    fn visit_str<E: ::serde::de::Error>(
                        self,
                        v: &str,
                    ) -> ::core::result::Result<CType, E> {
                        <CType as ::buffa::Enumeration>::from_proto_name(v)
                            .ok_or_else(|| {
                                ::serde::de::Error::unknown_variant(v, &[])
                            })
                    }
                    fn visit_i64<E: ::serde::de::Error>(
                        self,
                        v: i64,
                    ) -> ::core::result::Result<CType, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <CType as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_u64<E: ::serde::de::Error>(
                        self,
                        v: u64,
                    ) -> ::core::result::Result<CType, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <CType as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_unit<E: ::serde::de::Error>(
                        self,
                    ) -> ::core::result::Result<CType, E> {
                        ::core::result::Result::Ok(::core::default::Default::default())
                    }
                }
                d.deserialize_any(_V)
            }
        }
        impl ::buffa::json_helpers::ProtoElemJson for CType {
            fn serialize_proto_json<S: ::serde::Serializer>(
                v: &Self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                ::serde::Serialize::serialize(v, s)
            }
            fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                <Self as ::serde::Deserialize>::deserialize(d)
            }
        }
    };
    impl ::buffa::Enumeration for CType {
        fn from_i32(value: i32) -> ::core::option::Option<Self> {
            match value {
                0i32 => ::core::option::Option::Some(Self::STRING),
                1i32 => ::core::option::Option::Some(Self::CORD),
                2i32 => ::core::option::Option::Some(Self::STRING_PIECE),
                _ => ::core::option::Option::None,
            }
        }
        fn to_i32(&self) -> i32 {
            *self as i32
        }
        fn proto_name(&self) -> &'static str {
            match self {
                Self::STRING => "STRING",
                Self::CORD => "CORD",
                Self::STRING_PIECE => "STRING_PIECE",
            }
        }
        fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
            match name {
                "STRING" => ::core::option::Option::Some(Self::STRING),
                "CORD" => ::core::option::Option::Some(Self::CORD),
                "STRING_PIECE" => ::core::option::Option::Some(Self::STRING_PIECE),
                _ => ::core::option::Option::None,
            }
        }
        fn values() -> &'static [Self] {
            &[Self::STRING, Self::CORD, Self::STRING_PIECE]
        }
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    #[repr(i32)]
    pub enum JSType {
        /// Use the default type.
        JS_NORMAL = 0i32,
        /// Use JavaScript strings.
        JS_STRING = 1i32,
        /// Use JavaScript numbers.
        JS_NUMBER = 2i32,
    }
    impl JSType {
        ///Idiomatic alias for [`Self::JS_NORMAL`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const JsNormal: Self = Self::JS_NORMAL;
        ///Idiomatic alias for [`Self::JS_STRING`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const JsString: Self = Self::JS_STRING;
        ///Idiomatic alias for [`Self::JS_NUMBER`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const JsNumber: Self = Self::JS_NUMBER;
    }
    impl ::core::default::Default for JSType {
        fn default() -> Self {
            Self::JS_NORMAL
        }
    }
    #[cfg(feature = "json")]
    const _: () = {
        impl ::serde::Serialize for JSType {
            fn serialize<S: ::serde::Serializer>(
                &self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                s.serialize_str(::buffa::Enumeration::proto_name(self))
            }
        }
        impl<'de> ::serde::Deserialize<'de> for JSType {
            fn deserialize<D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                struct _V;
                impl ::serde::de::Visitor<'_> for _V {
                    type Value = JSType;
                    fn expecting(
                        &self,
                        f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        f.write_str(
                            concat!(
                                "a string, integer, or null for ", stringify!(JSType)
                            ),
                        )
                    }
                    fn visit_str<E: ::serde::de::Error>(
                        self,
                        v: &str,
                    ) -> ::core::result::Result<JSType, E> {
                        <JSType as ::buffa::Enumeration>::from_proto_name(v)
                            .ok_or_else(|| {
                                ::serde::de::Error::unknown_variant(v, &[])
                            })
                    }
                    fn visit_i64<E: ::serde::de::Error>(
                        self,
                        v: i64,
                    ) -> ::core::result::Result<JSType, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <JSType as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_u64<E: ::serde::de::Error>(
                        self,
                        v: u64,
                    ) -> ::core::result::Result<JSType, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <JSType as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_unit<E: ::serde::de::Error>(
                        self,
                    ) -> ::core::result::Result<JSType, E> {
                        ::core::result::Result::Ok(::core::default::Default::default())
                    }
                }
                d.deserialize_any(_V)
            }
        }
        impl ::buffa::json_helpers::ProtoElemJson for JSType {
            fn serialize_proto_json<S: ::serde::Serializer>(
                v: &Self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                ::serde::Serialize::serialize(v, s)
            }
            fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                <Self as ::serde::Deserialize>::deserialize(d)
            }
        }
    };
    impl ::buffa::Enumeration for JSType {
        fn from_i32(value: i32) -> ::core::option::Option<Self> {
            match value {
                0i32 => ::core::option::Option::Some(Self::JS_NORMAL),
                1i32 => ::core::option::Option::Some(Self::JS_STRING),
                2i32 => ::core::option::Option::Some(Self::JS_NUMBER),
                _ => ::core::option::Option::None,
            }
        }
        fn to_i32(&self) -> i32 {
            *self as i32
        }
        fn proto_name(&self) -> &'static str {
            match self {
                Self::JS_NORMAL => "JS_NORMAL",
                Self::JS_STRING => "JS_STRING",
                Self::JS_NUMBER => "JS_NUMBER",
            }
        }
        fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
            match name {
                "JS_NORMAL" => ::core::option::Option::Some(Self::JS_NORMAL),
                "JS_STRING" => ::core::option::Option::Some(Self::JS_STRING),
                "JS_NUMBER" => ::core::option::Option::Some(Self::JS_NUMBER),
                _ => ::core::option::Option::None,
            }
        }
        fn values() -> &'static [Self] {
            &[Self::JS_NORMAL, Self::JS_STRING, Self::JS_NUMBER]
        }
    }
    /// If set to RETENTION_SOURCE, the option will be omitted from the binary.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    #[repr(i32)]
    pub enum OptionRetention {
        RETENTION_UNKNOWN = 0i32,
        RETENTION_RUNTIME = 1i32,
        RETENTION_SOURCE = 2i32,
    }
    impl OptionRetention {
        ///Idiomatic alias for [`Self::RETENTION_UNKNOWN`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const RetentionUnknown: Self = Self::RETENTION_UNKNOWN;
        ///Idiomatic alias for [`Self::RETENTION_RUNTIME`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const RetentionRuntime: Self = Self::RETENTION_RUNTIME;
        ///Idiomatic alias for [`Self::RETENTION_SOURCE`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const RetentionSource: Self = Self::RETENTION_SOURCE;
    }
    impl ::core::default::Default for OptionRetention {
        fn default() -> Self {
            Self::RETENTION_UNKNOWN
        }
    }
    #[cfg(feature = "json")]
    const _: () = {
        impl ::serde::Serialize for OptionRetention {
            fn serialize<S: ::serde::Serializer>(
                &self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                s.serialize_str(::buffa::Enumeration::proto_name(self))
            }
        }
        impl<'de> ::serde::Deserialize<'de> for OptionRetention {
            fn deserialize<D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                struct _V;
                impl ::serde::de::Visitor<'_> for _V {
                    type Value = OptionRetention;
                    fn expecting(
                        &self,
                        f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        f.write_str(
                            concat!(
                                "a string, integer, or null for ",
                                stringify!(OptionRetention)
                            ),
                        )
                    }
                    fn visit_str<E: ::serde::de::Error>(
                        self,
                        v: &str,
                    ) -> ::core::result::Result<OptionRetention, E> {
                        <OptionRetention as ::buffa::Enumeration>::from_proto_name(v)
                            .ok_or_else(|| {
                                ::serde::de::Error::unknown_variant(v, &[])
                            })
                    }
                    fn visit_i64<E: ::serde::de::Error>(
                        self,
                        v: i64,
                    ) -> ::core::result::Result<OptionRetention, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <OptionRetention as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_u64<E: ::serde::de::Error>(
                        self,
                        v: u64,
                    ) -> ::core::result::Result<OptionRetention, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <OptionRetention as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_unit<E: ::serde::de::Error>(
                        self,
                    ) -> ::core::result::Result<OptionRetention, E> {
                        ::core::result::Result::Ok(::core::default::Default::default())
                    }
                }
                d.deserialize_any(_V)
            }
        }
        impl ::buffa::json_helpers::ProtoElemJson for OptionRetention {
            fn serialize_proto_json<S: ::serde::Serializer>(
                v: &Self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                ::serde::Serialize::serialize(v, s)
            }
            fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                <Self as ::serde::Deserialize>::deserialize(d)
            }
        }
    };
    impl ::buffa::Enumeration for OptionRetention {
        fn from_i32(value: i32) -> ::core::option::Option<Self> {
            match value {
                0i32 => ::core::option::Option::Some(Self::RETENTION_UNKNOWN),
                1i32 => ::core::option::Option::Some(Self::RETENTION_RUNTIME),
                2i32 => ::core::option::Option::Some(Self::RETENTION_SOURCE),
                _ => ::core::option::Option::None,
            }
        }
        fn to_i32(&self) -> i32 {
            *self as i32
        }
        fn proto_name(&self) -> &'static str {
            match self {
                Self::RETENTION_UNKNOWN => "RETENTION_UNKNOWN",
                Self::RETENTION_RUNTIME => "RETENTION_RUNTIME",
                Self::RETENTION_SOURCE => "RETENTION_SOURCE",
            }
        }
        fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
            match name {
                "RETENTION_UNKNOWN" => {
                    ::core::option::Option::Some(Self::RETENTION_UNKNOWN)
                }
                "RETENTION_RUNTIME" => {
                    ::core::option::Option::Some(Self::RETENTION_RUNTIME)
                }
                "RETENTION_SOURCE" => {
                    ::core::option::Option::Some(Self::RETENTION_SOURCE)
                }
                _ => ::core::option::Option::None,
            }
        }
        fn values() -> &'static [Self] {
            &[Self::RETENTION_UNKNOWN, Self::RETENTION_RUNTIME, Self::RETENTION_SOURCE]
        }
    }
    /// This indicates the types of entities that the field may apply to when used
    /// as an option. If it is unset, then the field may be freely used as an
    /// option on any kind of entity.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    #[repr(i32)]
    pub enum OptionTargetType {
        TARGET_TYPE_UNKNOWN = 0i32,
        TARGET_TYPE_FILE = 1i32,
        TARGET_TYPE_EXTENSION_RANGE = 2i32,
        TARGET_TYPE_MESSAGE = 3i32,
        TARGET_TYPE_FIELD = 4i32,
        TARGET_TYPE_ONEOF = 5i32,
        TARGET_TYPE_ENUM = 6i32,
        TARGET_TYPE_ENUM_ENTRY = 7i32,
        TARGET_TYPE_SERVICE = 8i32,
        TARGET_TYPE_METHOD = 9i32,
    }
    impl OptionTargetType {
        ///Idiomatic alias for [`Self::TARGET_TYPE_UNKNOWN`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const TargetTypeUnknown: Self = Self::TARGET_TYPE_UNKNOWN;
        ///Idiomatic alias for [`Self::TARGET_TYPE_FILE`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const TargetTypeFile: Self = Self::TARGET_TYPE_FILE;
        ///Idiomatic alias for [`Self::TARGET_TYPE_EXTENSION_RANGE`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const TargetTypeExtensionRange: Self = Self::TARGET_TYPE_EXTENSION_RANGE;
        ///Idiomatic alias for [`Self::TARGET_TYPE_MESSAGE`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const TargetTypeMessage: Self = Self::TARGET_TYPE_MESSAGE;
        ///Idiomatic alias for [`Self::TARGET_TYPE_FIELD`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const TargetTypeField: Self = Self::TARGET_TYPE_FIELD;
        ///Idiomatic alias for [`Self::TARGET_TYPE_ONEOF`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const TargetTypeOneof: Self = Self::TARGET_TYPE_ONEOF;
        ///Idiomatic alias for [`Self::TARGET_TYPE_ENUM`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const TargetTypeEnum: Self = Self::TARGET_TYPE_ENUM;
        ///Idiomatic alias for [`Self::TARGET_TYPE_ENUM_ENTRY`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const TargetTypeEnumEntry: Self = Self::TARGET_TYPE_ENUM_ENTRY;
        ///Idiomatic alias for [`Self::TARGET_TYPE_SERVICE`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const TargetTypeService: Self = Self::TARGET_TYPE_SERVICE;
        ///Idiomatic alias for [`Self::TARGET_TYPE_METHOD`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const TargetTypeMethod: Self = Self::TARGET_TYPE_METHOD;
    }
    impl ::core::default::Default for OptionTargetType {
        fn default() -> Self {
            Self::TARGET_TYPE_UNKNOWN
        }
    }
    #[cfg(feature = "json")]
    const _: () = {
        impl ::serde::Serialize for OptionTargetType {
            fn serialize<S: ::serde::Serializer>(
                &self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                s.serialize_str(::buffa::Enumeration::proto_name(self))
            }
        }
        impl<'de> ::serde::Deserialize<'de> for OptionTargetType {
            fn deserialize<D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                struct _V;
                impl ::serde::de::Visitor<'_> for _V {
                    type Value = OptionTargetType;
                    fn expecting(
                        &self,
                        f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        f.write_str(
                            concat!(
                                "a string, integer, or null for ",
                                stringify!(OptionTargetType)
                            ),
                        )
                    }
                    fn visit_str<E: ::serde::de::Error>(
                        self,
                        v: &str,
                    ) -> ::core::result::Result<OptionTargetType, E> {
                        <OptionTargetType as ::buffa::Enumeration>::from_proto_name(v)
                            .ok_or_else(|| {
                                ::serde::de::Error::unknown_variant(v, &[])
                            })
                    }
                    fn visit_i64<E: ::serde::de::Error>(
                        self,
                        v: i64,
                    ) -> ::core::result::Result<OptionTargetType, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <OptionTargetType as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_u64<E: ::serde::de::Error>(
                        self,
                        v: u64,
                    ) -> ::core::result::Result<OptionTargetType, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <OptionTargetType as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_unit<E: ::serde::de::Error>(
                        self,
                    ) -> ::core::result::Result<OptionTargetType, E> {
                        ::core::result::Result::Ok(::core::default::Default::default())
                    }
                }
                d.deserialize_any(_V)
            }
        }
        impl ::buffa::json_helpers::ProtoElemJson for OptionTargetType {
            fn serialize_proto_json<S: ::serde::Serializer>(
                v: &Self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                ::serde::Serialize::serialize(v, s)
            }
            fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                <Self as ::serde::Deserialize>::deserialize(d)
            }
        }
    };
    impl ::buffa::Enumeration for OptionTargetType {
        fn from_i32(value: i32) -> ::core::option::Option<Self> {
            match value {
                0i32 => ::core::option::Option::Some(Self::TARGET_TYPE_UNKNOWN),
                1i32 => ::core::option::Option::Some(Self::TARGET_TYPE_FILE),
                2i32 => ::core::option::Option::Some(Self::TARGET_TYPE_EXTENSION_RANGE),
                3i32 => ::core::option::Option::Some(Self::TARGET_TYPE_MESSAGE),
                4i32 => ::core::option::Option::Some(Self::TARGET_TYPE_FIELD),
                5i32 => ::core::option::Option::Some(Self::TARGET_TYPE_ONEOF),
                6i32 => ::core::option::Option::Some(Self::TARGET_TYPE_ENUM),
                7i32 => ::core::option::Option::Some(Self::TARGET_TYPE_ENUM_ENTRY),
                8i32 => ::core::option::Option::Some(Self::TARGET_TYPE_SERVICE),
                9i32 => ::core::option::Option::Some(Self::TARGET_TYPE_METHOD),
                _ => ::core::option::Option::None,
            }
        }
        fn to_i32(&self) -> i32 {
            *self as i32
        }
        fn proto_name(&self) -> &'static str {
            match self {
                Self::TARGET_TYPE_UNKNOWN => "TARGET_TYPE_UNKNOWN",
                Self::TARGET_TYPE_FILE => "TARGET_TYPE_FILE",
                Self::TARGET_TYPE_EXTENSION_RANGE => "TARGET_TYPE_EXTENSION_RANGE",
                Self::TARGET_TYPE_MESSAGE => "TARGET_TYPE_MESSAGE",
                Self::TARGET_TYPE_FIELD => "TARGET_TYPE_FIELD",
                Self::TARGET_TYPE_ONEOF => "TARGET_TYPE_ONEOF",
                Self::TARGET_TYPE_ENUM => "TARGET_TYPE_ENUM",
                Self::TARGET_TYPE_ENUM_ENTRY => "TARGET_TYPE_ENUM_ENTRY",
                Self::TARGET_TYPE_SERVICE => "TARGET_TYPE_SERVICE",
                Self::TARGET_TYPE_METHOD => "TARGET_TYPE_METHOD",
            }
        }
        fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
            match name {
                "TARGET_TYPE_UNKNOWN" => {
                    ::core::option::Option::Some(Self::TARGET_TYPE_UNKNOWN)
                }
                "TARGET_TYPE_FILE" => {
                    ::core::option::Option::Some(Self::TARGET_TYPE_FILE)
                }
                "TARGET_TYPE_EXTENSION_RANGE" => {
                    ::core::option::Option::Some(Self::TARGET_TYPE_EXTENSION_RANGE)
                }
                "TARGET_TYPE_MESSAGE" => {
                    ::core::option::Option::Some(Self::TARGET_TYPE_MESSAGE)
                }
                "TARGET_TYPE_FIELD" => {
                    ::core::option::Option::Some(Self::TARGET_TYPE_FIELD)
                }
                "TARGET_TYPE_ONEOF" => {
                    ::core::option::Option::Some(Self::TARGET_TYPE_ONEOF)
                }
                "TARGET_TYPE_ENUM" => {
                    ::core::option::Option::Some(Self::TARGET_TYPE_ENUM)
                }
                "TARGET_TYPE_ENUM_ENTRY" => {
                    ::core::option::Option::Some(Self::TARGET_TYPE_ENUM_ENTRY)
                }
                "TARGET_TYPE_SERVICE" => {
                    ::core::option::Option::Some(Self::TARGET_TYPE_SERVICE)
                }
                "TARGET_TYPE_METHOD" => {
                    ::core::option::Option::Some(Self::TARGET_TYPE_METHOD)
                }
                _ => ::core::option::Option::None,
            }
        }
        fn values() -> &'static [Self] {
            &[
                Self::TARGET_TYPE_UNKNOWN,
                Self::TARGET_TYPE_FILE,
                Self::TARGET_TYPE_EXTENSION_RANGE,
                Self::TARGET_TYPE_MESSAGE,
                Self::TARGET_TYPE_FIELD,
                Self::TARGET_TYPE_ONEOF,
                Self::TARGET_TYPE_ENUM,
                Self::TARGET_TYPE_ENUM_ENTRY,
                Self::TARGET_TYPE_SERVICE,
                Self::TARGET_TYPE_METHOD,
            ]
        }
    }
    #[derive(Clone, PartialEq, Default)]
    #[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
    #[cfg_attr(feature = "json", serde(default))]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    pub struct EditionDefault {
        /// Field 3: `edition`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "edition",
                with = "::buffa::json_helpers::opt_closed_enum",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub edition: ::core::option::Option<super::Edition>,
        /// Textproto value.
        ///
        /// Field 2: `value`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "value",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub value: ::core::option::Option<::buffa::alloc::string::String>,
        #[cfg_attr(feature = "json", serde(skip))]
        #[doc(hidden)]
        pub __buffa_unknown_fields: ::buffa::UnknownFields,
    }
    impl ::core::fmt::Debug for EditionDefault {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            f.debug_struct("EditionDefault")
                .field("edition", &self.edition)
                .field("value", &self.value)
                .finish()
        }
    }
    impl EditionDefault {
        /// Protobuf type URL for this message, for use with `Any::pack` and
        /// `Any::unpack_if`.
        ///
        /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
        pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FieldOptions.EditionDefault";
    }
    impl EditionDefault {
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::edition`] to `Some(value)`, consuming and returning `self`.
        pub fn with_edition(mut self, value: impl Into<super::Edition>) -> Self {
            self.edition = Some(value.into());
            self
        }
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::value`] to `Some(value)`, consuming and returning `self`.
        pub fn with_value(
            mut self,
            value: impl Into<::buffa::alloc::string::String>,
        ) -> Self {
            self.value = Some(value.into());
            self
        }
    }
    ::buffa::impl_default_instance!(EditionDefault);
    impl ::buffa::MessageName for EditionDefault {
        const PACKAGE: &'static str = "google.protobuf";
        const NAME: &'static str = "FieldOptions.EditionDefault";
        const FULL_NAME: &'static str = "google.protobuf.FieldOptions.EditionDefault";
        const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FieldOptions.EditionDefault";
    }
    impl ::buffa::Message for EditionDefault {
        /// Returns the total encoded size in bytes.
        ///
        /// Accumulates in `u64` (which cannot overflow for in-memory
        /// data) and saturates to `u32` at return, so a message whose
        /// encoded size exceeds the 2 GiB protobuf limit yields a value
        /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
        /// points reject, never a silently wrapped size.
        #[allow(clippy::let_and_return)]
        fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            let mut size = 0u64;
            if let Some(ref v) = self.value {
                size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
            }
            if let Some(ref v) = self.edition {
                size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
            }
            size += self.__buffa_unknown_fields.encoded_len() as u64;
            ::buffa::saturate_size(size)
        }
        fn write_to(
            &self,
            _cache: &mut ::buffa::SizeCache,
            buf: &mut impl ::buffa::EncodeSink,
        ) {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if let Some(ref v) = self.value {
                ::buffa::types::put_string_field(2u32, v, buf);
            }
            if let Some(ref v) = self.edition {
                ::buffa::types::put_int32_field(3u32, v.to_i32(), buf);
            }
            self.__buffa_unknown_fields.write_to(buf);
        }
        fn merge_field(
            &mut self,
            tag: ::buffa::encoding::Tag,
            buf: &mut impl ::buffa::bytes::Buf,
            ctx: ::buffa::DecodeContext<'_>,
        ) -> ::core::result::Result<(), ::buffa::DecodeError> {
            #[allow(unused_imports)]
            use ::buffa::bytes::Buf as _;
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            match tag.field_number() {
                2u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::LengthDelimited,
                    )?;
                    ::buffa::types::merge_string(
                        self
                            .value
                            .get_or_insert_with(::buffa::alloc::string::String::new),
                        buf,
                    )?;
                }
                3u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::Varint,
                    )?;
                    let __raw = ::buffa::types::decode_int32(buf)?;
                    if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                        __raw,
                    ) {
                        self.edition = ::core::option::Option::Some(__v);
                    } else {
                        ctx.register_unknown_field()?;
                        self.__buffa_unknown_fields
                            .push(::buffa::UnknownField {
                                number: 3u32,
                                data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                            });
                    }
                }
                _ => {
                    self.__buffa_unknown_fields
                        .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
                }
            }
            ::core::result::Result::Ok(())
        }
        fn clear(&mut self) {
            self.value = ::core::option::Option::None;
            self.edition = ::core::option::Option::None;
            self.__buffa_unknown_fields.clear();
        }
    }
    impl ::buffa::ExtensionSet for EditionDefault {
        const PROTO_FQN: &'static str = "google.protobuf.FieldOptions.EditionDefault";
        fn unknown_fields(&self) -> &::buffa::UnknownFields {
            &self.__buffa_unknown_fields
        }
        fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
            &mut self.__buffa_unknown_fields
        }
    }
    #[cfg(feature = "text")]
    impl ::buffa::text::TextFormat for EditionDefault {
        fn encode_text(
            &self,
            enc: &mut ::buffa::text::TextEncoder<'_>,
        ) -> ::core::fmt::Result {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if let ::core::option::Option::Some(ref __v) = self.edition {
                enc.write_field_name("edition")?;
                enc.write_enum_name(__v.proto_name())?;
            }
            if let ::core::option::Option::Some(ref __v) = self.value {
                enc.write_field_name("value")?;
                enc.write_string(__v)?;
            }
            enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
            ::core::result::Result::Ok(())
        }
        fn merge_text(
            &mut self,
            dec: &mut ::buffa::text::TextDecoder<'_>,
        ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
                match __name {
                    "edition" => {
                        self.edition = ::core::option::Option::Some(
                            dec.read_closed_enum_by_name::<super::Edition>()?,
                        );
                    }
                    "value" => {
                        self.value = ::core::option::Option::Some(
                            dec.read_string()?.into_owned(),
                        );
                    }
                    _ => dec.skip_value()?,
                }
            }
            ::core::result::Result::Ok(())
        }
    }
    #[cfg(feature = "json")]
    impl ::buffa::json_helpers::ProtoElemJson for EditionDefault {
        fn serialize_proto_json<S: ::serde::Serializer>(
            v: &Self,
            s: S,
        ) -> ::core::result::Result<S::Ok, S::Error> {
            ::serde::Serialize::serialize(v, s)
        }
        fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
            d: D,
        ) -> ::core::result::Result<Self, D::Error> {
            <Self as ::serde::Deserialize>::deserialize(d)
        }
    }
    #[cfg(feature = "json")]
    #[doc(hidden)]
    pub const __EDITION_DEFAULT_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.FieldOptions.EditionDefault",
        to_json: ::buffa::type_registry::any_to_json::<EditionDefault>,
        from_json: ::buffa::type_registry::any_from_json::<EditionDefault>,
        is_wkt: false,
    };
    #[cfg(feature = "text")]
    #[doc(hidden)]
    pub const __EDITION_DEFAULT_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.FieldOptions.EditionDefault",
        text_encode: ::buffa::type_registry::any_encode_text::<EditionDefault>,
        text_merge: ::buffa::type_registry::any_merge_text::<EditionDefault>,
    };
    /// Information about the support window of a feature.
    #[derive(Clone, PartialEq, Default)]
    #[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
    #[cfg_attr(feature = "json", serde(default))]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    pub struct FeatureSupport {
        /// The edition that this feature was first available in.  In editions
        /// earlier than this one, the default assigned to EDITION_LEGACY will be
        /// used, and proto files will not be able to override it.
        ///
        /// Field 1: `edition_introduced`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "editionIntroduced",
                alias = "edition_introduced",
                with = "::buffa::json_helpers::opt_closed_enum",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub edition_introduced: ::core::option::Option<super::Edition>,
        /// The edition this feature becomes deprecated in.  Using this after this
        /// edition may trigger warnings.
        ///
        /// Field 2: `edition_deprecated`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "editionDeprecated",
                alias = "edition_deprecated",
                with = "::buffa::json_helpers::opt_closed_enum",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub edition_deprecated: ::core::option::Option<super::Edition>,
        /// The deprecation warning text if this feature is used after the edition it
        /// was marked deprecated in.
        ///
        /// Field 3: `deprecation_warning`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "deprecationWarning",
                alias = "deprecation_warning",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub deprecation_warning: ::core::option::Option<::buffa::alloc::string::String>,
        /// The edition this feature is no longer available in.  In editions after
        /// this one, the last default assigned will be used, and proto files will
        /// not be able to override it.
        ///
        /// Field 4: `edition_removed`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "editionRemoved",
                alias = "edition_removed",
                with = "::buffa::json_helpers::opt_closed_enum",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub edition_removed: ::core::option::Option<super::Edition>,
        #[cfg_attr(feature = "json", serde(skip))]
        #[doc(hidden)]
        pub __buffa_unknown_fields: ::buffa::UnknownFields,
    }
    impl ::core::fmt::Debug for FeatureSupport {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            f.debug_struct("FeatureSupport")
                .field("edition_introduced", &self.edition_introduced)
                .field("edition_deprecated", &self.edition_deprecated)
                .field("deprecation_warning", &self.deprecation_warning)
                .field("edition_removed", &self.edition_removed)
                .finish()
        }
    }
    impl FeatureSupport {
        /// Protobuf type URL for this message, for use with `Any::pack` and
        /// `Any::unpack_if`.
        ///
        /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
        pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FieldOptions.FeatureSupport";
    }
    impl FeatureSupport {
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::edition_introduced`] to `Some(value)`, consuming and returning `self`.
        pub fn with_edition_introduced(
            mut self,
            value: impl Into<super::Edition>,
        ) -> Self {
            self.edition_introduced = Some(value.into());
            self
        }
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::edition_deprecated`] to `Some(value)`, consuming and returning `self`.
        pub fn with_edition_deprecated(
            mut self,
            value: impl Into<super::Edition>,
        ) -> Self {
            self.edition_deprecated = Some(value.into());
            self
        }
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::deprecation_warning`] to `Some(value)`, consuming and returning `self`.
        pub fn with_deprecation_warning(
            mut self,
            value: impl Into<::buffa::alloc::string::String>,
        ) -> Self {
            self.deprecation_warning = Some(value.into());
            self
        }
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::edition_removed`] to `Some(value)`, consuming and returning `self`.
        pub fn with_edition_removed(mut self, value: impl Into<super::Edition>) -> Self {
            self.edition_removed = Some(value.into());
            self
        }
    }
    ::buffa::impl_default_instance!(FeatureSupport);
    impl ::buffa::MessageName for FeatureSupport {
        const PACKAGE: &'static str = "google.protobuf";
        const NAME: &'static str = "FieldOptions.FeatureSupport";
        const FULL_NAME: &'static str = "google.protobuf.FieldOptions.FeatureSupport";
        const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FieldOptions.FeatureSupport";
    }
    impl ::buffa::Message for FeatureSupport {
        /// Returns the total encoded size in bytes.
        ///
        /// Accumulates in `u64` (which cannot overflow for in-memory
        /// data) and saturates to `u32` at return, so a message whose
        /// encoded size exceeds the 2 GiB protobuf limit yields a value
        /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
        /// points reject, never a silently wrapped size.
        #[allow(clippy::let_and_return)]
        fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            let mut size = 0u64;
            if let Some(ref v) = self.edition_introduced {
                size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
            }
            if let Some(ref v) = self.edition_deprecated {
                size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
            }
            if let Some(ref v) = self.deprecation_warning {
                size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
            }
            if let Some(ref v) = self.edition_removed {
                size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
            }
            size += self.__buffa_unknown_fields.encoded_len() as u64;
            ::buffa::saturate_size(size)
        }
        fn write_to(
            &self,
            _cache: &mut ::buffa::SizeCache,
            buf: &mut impl ::buffa::EncodeSink,
        ) {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if let Some(ref v) = self.edition_introduced {
                ::buffa::types::put_int32_field(1u32, v.to_i32(), buf);
            }
            if let Some(ref v) = self.edition_deprecated {
                ::buffa::types::put_int32_field(2u32, v.to_i32(), buf);
            }
            if let Some(ref v) = self.deprecation_warning {
                ::buffa::types::put_string_field(3u32, v, buf);
            }
            if let Some(ref v) = self.edition_removed {
                ::buffa::types::put_int32_field(4u32, v.to_i32(), buf);
            }
            self.__buffa_unknown_fields.write_to(buf);
        }
        fn merge_field(
            &mut self,
            tag: ::buffa::encoding::Tag,
            buf: &mut impl ::buffa::bytes::Buf,
            ctx: ::buffa::DecodeContext<'_>,
        ) -> ::core::result::Result<(), ::buffa::DecodeError> {
            #[allow(unused_imports)]
            use ::buffa::bytes::Buf as _;
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            match tag.field_number() {
                1u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::Varint,
                    )?;
                    let __raw = ::buffa::types::decode_int32(buf)?;
                    if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                        __raw,
                    ) {
                        self.edition_introduced = ::core::option::Option::Some(__v);
                    } else {
                        ctx.register_unknown_field()?;
                        self.__buffa_unknown_fields
                            .push(::buffa::UnknownField {
                                number: 1u32,
                                data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                            });
                    }
                }
                2u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::Varint,
                    )?;
                    let __raw = ::buffa::types::decode_int32(buf)?;
                    if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                        __raw,
                    ) {
                        self.edition_deprecated = ::core::option::Option::Some(__v);
                    } else {
                        ctx.register_unknown_field()?;
                        self.__buffa_unknown_fields
                            .push(::buffa::UnknownField {
                                number: 2u32,
                                data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                            });
                    }
                }
                3u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::LengthDelimited,
                    )?;
                    ::buffa::types::merge_string(
                        self
                            .deprecation_warning
                            .get_or_insert_with(::buffa::alloc::string::String::new),
                        buf,
                    )?;
                }
                4u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::Varint,
                    )?;
                    let __raw = ::buffa::types::decode_int32(buf)?;
                    if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                        __raw,
                    ) {
                        self.edition_removed = ::core::option::Option::Some(__v);
                    } else {
                        ctx.register_unknown_field()?;
                        self.__buffa_unknown_fields
                            .push(::buffa::UnknownField {
                                number: 4u32,
                                data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                            });
                    }
                }
                _ => {
                    self.__buffa_unknown_fields
                        .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
                }
            }
            ::core::result::Result::Ok(())
        }
        fn clear(&mut self) {
            self.edition_introduced = ::core::option::Option::None;
            self.edition_deprecated = ::core::option::Option::None;
            self.deprecation_warning = ::core::option::Option::None;
            self.edition_removed = ::core::option::Option::None;
            self.__buffa_unknown_fields.clear();
        }
    }
    impl ::buffa::ExtensionSet for FeatureSupport {
        const PROTO_FQN: &'static str = "google.protobuf.FieldOptions.FeatureSupport";
        fn unknown_fields(&self) -> &::buffa::UnknownFields {
            &self.__buffa_unknown_fields
        }
        fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
            &mut self.__buffa_unknown_fields
        }
    }
    #[cfg(feature = "text")]
    impl ::buffa::text::TextFormat for FeatureSupport {
        fn encode_text(
            &self,
            enc: &mut ::buffa::text::TextEncoder<'_>,
        ) -> ::core::fmt::Result {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if let ::core::option::Option::Some(ref __v) = self.edition_introduced {
                enc.write_field_name("edition_introduced")?;
                enc.write_enum_name(__v.proto_name())?;
            }
            if let ::core::option::Option::Some(ref __v) = self.edition_deprecated {
                enc.write_field_name("edition_deprecated")?;
                enc.write_enum_name(__v.proto_name())?;
            }
            if let ::core::option::Option::Some(ref __v) = self.deprecation_warning {
                enc.write_field_name("deprecation_warning")?;
                enc.write_string(__v)?;
            }
            if let ::core::option::Option::Some(ref __v) = self.edition_removed {
                enc.write_field_name("edition_removed")?;
                enc.write_enum_name(__v.proto_name())?;
            }
            enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
            ::core::result::Result::Ok(())
        }
        fn merge_text(
            &mut self,
            dec: &mut ::buffa::text::TextDecoder<'_>,
        ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
                match __name {
                    "edition_introduced" => {
                        self.edition_introduced = ::core::option::Option::Some(
                            dec.read_closed_enum_by_name::<super::Edition>()?,
                        );
                    }
                    "edition_deprecated" => {
                        self.edition_deprecated = ::core::option::Option::Some(
                            dec.read_closed_enum_by_name::<super::Edition>()?,
                        );
                    }
                    "deprecation_warning" => {
                        self.deprecation_warning = ::core::option::Option::Some(
                            dec.read_string()?.into_owned(),
                        );
                    }
                    "edition_removed" => {
                        self.edition_removed = ::core::option::Option::Some(
                            dec.read_closed_enum_by_name::<super::Edition>()?,
                        );
                    }
                    _ => dec.skip_value()?,
                }
            }
            ::core::result::Result::Ok(())
        }
    }
    #[cfg(feature = "json")]
    impl ::buffa::json_helpers::ProtoElemJson for FeatureSupport {
        fn serialize_proto_json<S: ::serde::Serializer>(
            v: &Self,
            s: S,
        ) -> ::core::result::Result<S::Ok, S::Error> {
            ::serde::Serialize::serialize(v, s)
        }
        fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
            d: D,
        ) -> ::core::result::Result<Self, D::Error> {
            <Self as ::serde::Deserialize>::deserialize(d)
        }
    }
    #[cfg(feature = "json")]
    #[doc(hidden)]
    pub const __FEATURE_SUPPORT_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.FieldOptions.FeatureSupport",
        to_json: ::buffa::type_registry::any_to_json::<FeatureSupport>,
        from_json: ::buffa::type_registry::any_from_json::<FeatureSupport>,
        is_wkt: false,
    };
    #[cfg(feature = "text")]
    #[doc(hidden)]
    pub const __FEATURE_SUPPORT_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.FieldOptions.FeatureSupport",
        text_encode: ::buffa::type_registry::any_encode_text::<FeatureSupport>,
        text_merge: ::buffa::type_registry::any_merge_text::<FeatureSupport>,
    };
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::field_options::EditionDefaultView;
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::field_options::EditionDefaultOwnedView;
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::field_options::FeatureSupportView;
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::field_options::FeatureSupportOwnedView;
}
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct OneofOptions {
    /// Any features defined in the specific edition.
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    ///
    /// Field 1: `features`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "features",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub features: ::buffa::MessageField<FeatureSet, ::buffa::Inline<FeatureSet>>,
    /// The parser stores options it doesn't recognize here. See above.
    ///
    /// Field 999: `uninterpreted_option`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "uninterpretedOption",
            alias = "uninterpreted_option",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub uninterpreted_option: ::buffa::alloc::vec::Vec<UninterpretedOption>,
    #[cfg_attr(feature = "json", serde(flatten))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: __OneofOptionsExtJson,
}
impl ::core::fmt::Debug for OneofOptions {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("OneofOptions")
            .field("features", &self.features)
            .field("uninterpreted_option", &self.uninterpreted_option)
            .finish()
    }
}
impl OneofOptions {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.OneofOptions";
}
::buffa::impl_default_instance!(OneofOptions);
impl ::buffa::MessageName for OneofOptions {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "OneofOptions";
    const FULL_NAME: &'static str = "google.protobuf.OneofOptions";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.OneofOptions";
}
impl ::buffa::Message for OneofOptions {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if self.features.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.features.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.uninterpreted_option {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 2u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.features.is_set() {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.features.write_to(__cache, buf);
        }
        for v in &self.uninterpreted_option {
            ::buffa::types::put_len_delimited_header(
                999u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.features.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            999u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.uninterpreted_option.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.features = ::buffa::MessageField::none();
        self.uninterpreted_option.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for OneofOptions {
    const PROTO_FQN: &'static str = "google.protobuf.OneofOptions";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for OneofOptions {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.features.is_set() {
            enc.write_field_name("features")?;
            enc.write_message(&*self.features)?;
        }
        for __v in &self.uninterpreted_option {
            enc.write_field_name("uninterpreted_option")?;
            enc.write_message(__v)?;
        }
        enc.write_extension_fields(
            "google.protobuf.OneofOptions",
            &self.__buffa_unknown_fields,
        )?;
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "features" => dec.merge_message(self.features.get_or_insert_default())?,
                "uninterpreted_option" => {
                    dec.read_repeated_into(
                        &mut self.uninterpreted_option,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                __name if __name.starts_with('[') => {
                    for __r in dec
                        .read_extension(__name, "google.protobuf.OneofOptions")?
                    {
                        self.__buffa_unknown_fields.push(__r);
                    }
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl<'de> serde::Deserialize<'de> for OneofOptions {
    fn deserialize<D: serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl<'de> serde::de::Visitor<'de> for _V {
            type Value = OneofOptions;
            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                f.write_str("struct OneofOptions")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<OneofOptions, A::Error> {
                let mut __f_features: ::core::option::Option<
                    ::buffa::MessageField<FeatureSet, ::buffa::Inline<FeatureSet>>,
                > = None;
                let mut __f_uninterpreted_option: ::core::option::Option<
                    ::buffa::alloc::vec::Vec<UninterpretedOption>,
                > = None;
                let mut __ext_records: ::buffa::alloc::vec::Vec<::buffa::UnknownField> = ::buffa::alloc::vec::Vec::new();
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "features" => {
                            __f_features = Some(
                                map
                                    .next_value::<
                                        ::buffa::MessageField<
                                            FeatureSet,
                                            ::buffa::Inline<FeatureSet>,
                                        >,
                                    >()?,
                            );
                        }
                        "uninterpretedOption" | "uninterpreted_option" => {
                            __f_uninterpreted_option = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::buffa::alloc::vec::Vec<UninterpretedOption>;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::buffa::alloc::vec::Vec<UninterpretedOption>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::null_as_default(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        __k if __k.starts_with('[') => {
                            let __v: ::buffa::serde_json::Value = map.next_value()?;
                            match ::buffa::extension_registry::deserialize_extension_key(
                                "google.protobuf.OneofOptions",
                                __k,
                                __v,
                            ) {
                                ::core::option::Option::Some(
                                    ::core::result::Result::Ok(__recs),
                                ) => {
                                    for __rec in __recs {
                                        __ext_records.push(__rec);
                                    }
                                }
                                ::core::option::Option::Some(
                                    ::core::result::Result::Err(__e),
                                ) => {
                                    return ::core::result::Result::Err(
                                        <A::Error as ::serde::de::Error>::custom(__e),
                                    );
                                }
                                ::core::option::Option::None => {}
                            }
                        }
                        _ => {
                            map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                let mut __r = <OneofOptions as ::core::default::Default>::default();
                if let ::core::option::Option::Some(v) = __f_features {
                    __r.features = v;
                }
                if let ::core::option::Option::Some(v) = __f_uninterpreted_option {
                    __r.uninterpreted_option = v;
                }
                for __rec in __ext_records {
                    __r.__buffa_unknown_fields.push(__rec);
                }
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for OneofOptions {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
#[derive(Clone, Debug, Default, PartialEq)]
#[repr(transparent)]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct __OneofOptionsExtJson(pub ::buffa::UnknownFields);
impl ::core::ops::Deref for __OneofOptionsExtJson {
    type Target = ::buffa::UnknownFields;
    fn deref(&self) -> &::buffa::UnknownFields {
        &self.0
    }
}
impl ::core::ops::DerefMut for __OneofOptionsExtJson {
    fn deref_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.0
    }
}
impl ::core::convert::From<::buffa::UnknownFields> for __OneofOptionsExtJson {
    fn from(u: ::buffa::UnknownFields) -> Self {
        Self(u)
    }
}
#[cfg(feature = "json")]
impl ::serde::Serialize for __OneofOptionsExtJson {
    fn serialize<S: ::serde::Serializer>(
        &self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::buffa::extension_registry::serialize_extensions(
            "google.protobuf.OneofOptions",
            &self.0,
            s,
        )
    }
}
#[cfg(feature = "json")]
impl<'de> ::serde::Deserialize<'de> for __OneofOptionsExtJson {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        ::buffa::extension_registry::deserialize_extensions(
                "google.protobuf.OneofOptions",
                d,
            )
            .map(Self)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __ONEOF_OPTIONS_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.OneofOptions",
    to_json: ::buffa::type_registry::any_to_json::<OneofOptions>,
    from_json: ::buffa::type_registry::any_from_json::<OneofOptions>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __ONEOF_OPTIONS_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.OneofOptions",
    text_encode: ::buffa::type_registry::any_encode_text::<OneofOptions>,
    text_merge: ::buffa::type_registry::any_merge_text::<OneofOptions>,
};
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct EnumOptions {
    /// Set this option to true to allow mapping different tag names to the same
    /// value.
    ///
    /// Field 2: `allow_alias`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "allowAlias",
            alias = "allow_alias",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub allow_alias: ::core::option::Option<bool>,
    /// Is this enum deprecated?
    /// Depending on the target platform, this can emit Deprecated annotations
    /// for the enum, or it will be completely ignored; in the very least, this
    /// is a formalization for deprecating enums.
    ///
    /// Field 3: `deprecated`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "deprecated",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub deprecated: ::core::option::Option<bool>,
    /// Enable the legacy handling of JSON field name conflicts.  This lowercases
    /// and strips underscored from the fields before comparison in proto3 only.
    /// The new behavior takes `json_name` into account and applies to proto2 as
    /// well.
    /// TODO Remove this legacy behavior once downstream teams have
    /// had time to migrate.
    ///
    /// Field 6: `deprecated_legacy_json_field_conflicts`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "deprecatedLegacyJsonFieldConflicts",
            alias = "deprecated_legacy_json_field_conflicts",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub deprecated_legacy_json_field_conflicts: ::core::option::Option<bool>,
    /// Any features defined in the specific edition.
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    ///
    /// Field 7: `features`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "features",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub features: ::buffa::MessageField<FeatureSet, ::buffa::Inline<FeatureSet>>,
    /// The parser stores options it doesn't recognize here. See above.
    ///
    /// Field 999: `uninterpreted_option`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "uninterpretedOption",
            alias = "uninterpreted_option",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub uninterpreted_option: ::buffa::alloc::vec::Vec<UninterpretedOption>,
    #[cfg_attr(feature = "json", serde(flatten))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: __EnumOptionsExtJson,
}
impl ::core::fmt::Debug for EnumOptions {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("EnumOptions")
            .field("allow_alias", &self.allow_alias)
            .field("deprecated", &self.deprecated)
            .field(
                "deprecated_legacy_json_field_conflicts",
                &self.deprecated_legacy_json_field_conflicts,
            )
            .field("features", &self.features)
            .field("uninterpreted_option", &self.uninterpreted_option)
            .finish()
    }
}
impl EnumOptions {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.EnumOptions";
}
impl EnumOptions {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::allow_alias`] to `Some(value)`, consuming and returning `self`.
    pub fn with_allow_alias(mut self, value: bool) -> Self {
        self.allow_alias = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::deprecated`] to `Some(value)`, consuming and returning `self`.
    pub fn with_deprecated(mut self, value: bool) -> Self {
        self.deprecated = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::deprecated_legacy_json_field_conflicts`] to `Some(value)`, consuming and returning `self`.
    pub fn with_deprecated_legacy_json_field_conflicts(mut self, value: bool) -> Self {
        self.deprecated_legacy_json_field_conflicts = Some(value);
        self
    }
}
::buffa::impl_default_instance!(EnumOptions);
impl ::buffa::MessageName for EnumOptions {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "EnumOptions";
    const FULL_NAME: &'static str = "google.protobuf.EnumOptions";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.EnumOptions";
}
impl ::buffa::Message for EnumOptions {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if self.allow_alias.is_some() {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.deprecated.is_some() {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.deprecated_legacy_json_field_conflicts.is_some() {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.features.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.features.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.uninterpreted_option {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 2u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let Some(v) = self.allow_alias {
            ::buffa::types::put_bool_field(2u32, v, buf);
        }
        if let Some(v) = self.deprecated {
            ::buffa::types::put_bool_field(3u32, v, buf);
        }
        if let Some(v) = self.deprecated_legacy_json_field_conflicts {
            ::buffa::types::put_bool_field(6u32, v, buf);
        }
        if self.features.is_set() {
            ::buffa::types::put_len_delimited_header(
                7u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.features.write_to(__cache, buf);
        }
        for v in &self.uninterpreted_option {
            ::buffa::types::put_len_delimited_header(
                999u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.allow_alias = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.deprecated = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.deprecated_legacy_json_field_conflicts = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.features.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            999u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.uninterpreted_option.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.allow_alias = ::core::option::Option::None;
        self.deprecated = ::core::option::Option::None;
        self.deprecated_legacy_json_field_conflicts = ::core::option::Option::None;
        self.features = ::buffa::MessageField::none();
        self.uninterpreted_option.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for EnumOptions {
    const PROTO_FQN: &'static str = "google.protobuf.EnumOptions";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for EnumOptions {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref __v) = self.allow_alias {
            enc.write_field_name("allow_alias")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.deprecated {
            enc.write_field_name("deprecated")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self
            .deprecated_legacy_json_field_conflicts
        {
            enc.write_field_name("deprecated_legacy_json_field_conflicts")?;
            enc.write_bool(*__v)?;
        }
        if self.features.is_set() {
            enc.write_field_name("features")?;
            enc.write_message(&*self.features)?;
        }
        for __v in &self.uninterpreted_option {
            enc.write_field_name("uninterpreted_option")?;
            enc.write_message(__v)?;
        }
        enc.write_extension_fields(
            "google.protobuf.EnumOptions",
            &self.__buffa_unknown_fields,
        )?;
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "allow_alias" => {
                    self.allow_alias = ::core::option::Option::Some(dec.read_bool()?);
                }
                "deprecated" => {
                    self.deprecated = ::core::option::Option::Some(dec.read_bool()?);
                }
                "deprecated_legacy_json_field_conflicts" => {
                    self.deprecated_legacy_json_field_conflicts = ::core::option::Option::Some(
                        dec.read_bool()?,
                    );
                }
                "features" => dec.merge_message(self.features.get_or_insert_default())?,
                "uninterpreted_option" => {
                    dec.read_repeated_into(
                        &mut self.uninterpreted_option,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                __name if __name.starts_with('[') => {
                    for __r in dec.read_extension(__name, "google.protobuf.EnumOptions")?
                    {
                        self.__buffa_unknown_fields.push(__r);
                    }
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl<'de> serde::Deserialize<'de> for EnumOptions {
    fn deserialize<D: serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl<'de> serde::de::Visitor<'de> for _V {
            type Value = EnumOptions;
            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                f.write_str("struct EnumOptions")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<EnumOptions, A::Error> {
                let mut __f_allow_alias: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_deprecated: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_deprecated_legacy_json_field_conflicts: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_features: ::core::option::Option<
                    ::buffa::MessageField<FeatureSet, ::buffa::Inline<FeatureSet>>,
                > = None;
                let mut __f_uninterpreted_option: ::core::option::Option<
                    ::buffa::alloc::vec::Vec<UninterpretedOption>,
                > = None;
                let mut __ext_records: ::buffa::alloc::vec::Vec<::buffa::UnknownField> = ::buffa::alloc::vec::Vec::new();
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "allowAlias" | "allow_alias" => {
                            __f_allow_alias = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "deprecated" => {
                            __f_deprecated = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "deprecatedLegacyJsonFieldConflicts"
                        | "deprecated_legacy_json_field_conflicts" => {
                            __f_deprecated_legacy_json_field_conflicts = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "features" => {
                            __f_features = Some(
                                map
                                    .next_value::<
                                        ::buffa::MessageField<
                                            FeatureSet,
                                            ::buffa::Inline<FeatureSet>,
                                        >,
                                    >()?,
                            );
                        }
                        "uninterpretedOption" | "uninterpreted_option" => {
                            __f_uninterpreted_option = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::buffa::alloc::vec::Vec<UninterpretedOption>;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::buffa::alloc::vec::Vec<UninterpretedOption>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::null_as_default(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        __k if __k.starts_with('[') => {
                            let __v: ::buffa::serde_json::Value = map.next_value()?;
                            match ::buffa::extension_registry::deserialize_extension_key(
                                "google.protobuf.EnumOptions",
                                __k,
                                __v,
                            ) {
                                ::core::option::Option::Some(
                                    ::core::result::Result::Ok(__recs),
                                ) => {
                                    for __rec in __recs {
                                        __ext_records.push(__rec);
                                    }
                                }
                                ::core::option::Option::Some(
                                    ::core::result::Result::Err(__e),
                                ) => {
                                    return ::core::result::Result::Err(
                                        <A::Error as ::serde::de::Error>::custom(__e),
                                    );
                                }
                                ::core::option::Option::None => {}
                            }
                        }
                        _ => {
                            map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                let mut __r = <EnumOptions as ::core::default::Default>::default();
                if let ::core::option::Option::Some(v) = __f_allow_alias {
                    __r.allow_alias = v;
                }
                if let ::core::option::Option::Some(v) = __f_deprecated {
                    __r.deprecated = v;
                }
                if let ::core::option::Option::Some(v) = __f_deprecated_legacy_json_field_conflicts {
                    __r.deprecated_legacy_json_field_conflicts = v;
                }
                if let ::core::option::Option::Some(v) = __f_features {
                    __r.features = v;
                }
                if let ::core::option::Option::Some(v) = __f_uninterpreted_option {
                    __r.uninterpreted_option = v;
                }
                for __rec in __ext_records {
                    __r.__buffa_unknown_fields.push(__rec);
                }
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for EnumOptions {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
#[derive(Clone, Debug, Default, PartialEq)]
#[repr(transparent)]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct __EnumOptionsExtJson(pub ::buffa::UnknownFields);
impl ::core::ops::Deref for __EnumOptionsExtJson {
    type Target = ::buffa::UnknownFields;
    fn deref(&self) -> &::buffa::UnknownFields {
        &self.0
    }
}
impl ::core::ops::DerefMut for __EnumOptionsExtJson {
    fn deref_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.0
    }
}
impl ::core::convert::From<::buffa::UnknownFields> for __EnumOptionsExtJson {
    fn from(u: ::buffa::UnknownFields) -> Self {
        Self(u)
    }
}
#[cfg(feature = "json")]
impl ::serde::Serialize for __EnumOptionsExtJson {
    fn serialize<S: ::serde::Serializer>(
        &self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::buffa::extension_registry::serialize_extensions(
            "google.protobuf.EnumOptions",
            &self.0,
            s,
        )
    }
}
#[cfg(feature = "json")]
impl<'de> ::serde::Deserialize<'de> for __EnumOptionsExtJson {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        ::buffa::extension_registry::deserialize_extensions(
                "google.protobuf.EnumOptions",
                d,
            )
            .map(Self)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __ENUM_OPTIONS_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.EnumOptions",
    to_json: ::buffa::type_registry::any_to_json::<EnumOptions>,
    from_json: ::buffa::type_registry::any_from_json::<EnumOptions>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __ENUM_OPTIONS_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.EnumOptions",
    text_encode: ::buffa::type_registry::any_encode_text::<EnumOptions>,
    text_merge: ::buffa::type_registry::any_merge_text::<EnumOptions>,
};
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct EnumValueOptions {
    /// Is this enum value deprecated?
    /// Depending on the target platform, this can emit Deprecated annotations
    /// for the enum value, or it will be completely ignored; in the very least,
    /// this is a formalization for deprecating enum values.
    ///
    /// Field 1: `deprecated`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "deprecated",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub deprecated: ::core::option::Option<bool>,
    /// Any features defined in the specific edition.
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    ///
    /// Field 2: `features`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "features",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub features: ::buffa::MessageField<FeatureSet, ::buffa::Inline<FeatureSet>>,
    /// Indicate that fields annotated with this enum value should not be printed
    /// out when using debug formats, e.g. when the field contains sensitive
    /// credentials.
    ///
    /// Field 3: `debug_redact`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "debugRedact",
            alias = "debug_redact",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub debug_redact: ::core::option::Option<bool>,
    /// Information about the support window of a feature value.
    ///
    /// Field 4: `feature_support`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "featureSupport",
            alias = "feature_support",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub feature_support: ::buffa::MessageField<
        field_options::FeatureSupport,
        ::buffa::Inline<field_options::FeatureSupport>,
    >,
    /// The parser stores options it doesn't recognize here. See above.
    ///
    /// Field 999: `uninterpreted_option`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "uninterpretedOption",
            alias = "uninterpreted_option",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub uninterpreted_option: ::buffa::alloc::vec::Vec<UninterpretedOption>,
    #[cfg_attr(feature = "json", serde(flatten))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: __EnumValueOptionsExtJson,
}
impl ::core::fmt::Debug for EnumValueOptions {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("EnumValueOptions")
            .field("deprecated", &self.deprecated)
            .field("features", &self.features)
            .field("debug_redact", &self.debug_redact)
            .field("feature_support", &self.feature_support)
            .field("uninterpreted_option", &self.uninterpreted_option)
            .finish()
    }
}
impl EnumValueOptions {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.EnumValueOptions";
}
impl EnumValueOptions {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::deprecated`] to `Some(value)`, consuming and returning `self`.
    pub fn with_deprecated(mut self, value: bool) -> Self {
        self.deprecated = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::debug_redact`] to `Some(value)`, consuming and returning `self`.
    pub fn with_debug_redact(mut self, value: bool) -> Self {
        self.debug_redact = Some(value);
        self
    }
}
::buffa::impl_default_instance!(EnumValueOptions);
impl ::buffa::MessageName for EnumValueOptions {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "EnumValueOptions";
    const FULL_NAME: &'static str = "google.protobuf.EnumValueOptions";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.EnumValueOptions";
}
impl ::buffa::Message for EnumValueOptions {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if self.deprecated.is_some() {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.features.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.features.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if self.debug_redact.is_some() {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.feature_support.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.feature_support.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.uninterpreted_option {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 2u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let Some(v) = self.deprecated {
            ::buffa::types::put_bool_field(1u32, v, buf);
        }
        if self.features.is_set() {
            ::buffa::types::put_len_delimited_header(
                2u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.features.write_to(__cache, buf);
        }
        if let Some(v) = self.debug_redact {
            ::buffa::types::put_bool_field(3u32, v, buf);
        }
        if self.feature_support.is_set() {
            ::buffa::types::put_len_delimited_header(
                4u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.feature_support.write_to(__cache, buf);
        }
        for v in &self.uninterpreted_option {
            ::buffa::types::put_len_delimited_header(
                999u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.deprecated = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.features.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.debug_redact = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.feature_support.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            999u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.uninterpreted_option.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.deprecated = ::core::option::Option::None;
        self.features = ::buffa::MessageField::none();
        self.debug_redact = ::core::option::Option::None;
        self.feature_support = ::buffa::MessageField::none();
        self.uninterpreted_option.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for EnumValueOptions {
    const PROTO_FQN: &'static str = "google.protobuf.EnumValueOptions";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for EnumValueOptions {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref __v) = self.deprecated {
            enc.write_field_name("deprecated")?;
            enc.write_bool(*__v)?;
        }
        if self.features.is_set() {
            enc.write_field_name("features")?;
            enc.write_message(&*self.features)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.debug_redact {
            enc.write_field_name("debug_redact")?;
            enc.write_bool(*__v)?;
        }
        if self.feature_support.is_set() {
            enc.write_field_name("feature_support")?;
            enc.write_message(&*self.feature_support)?;
        }
        for __v in &self.uninterpreted_option {
            enc.write_field_name("uninterpreted_option")?;
            enc.write_message(__v)?;
        }
        enc.write_extension_fields(
            "google.protobuf.EnumValueOptions",
            &self.__buffa_unknown_fields,
        )?;
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "deprecated" => {
                    self.deprecated = ::core::option::Option::Some(dec.read_bool()?);
                }
                "features" => dec.merge_message(self.features.get_or_insert_default())?,
                "debug_redact" => {
                    self.debug_redact = ::core::option::Option::Some(dec.read_bool()?);
                }
                "feature_support" => {
                    dec.merge_message(self.feature_support.get_or_insert_default())?
                }
                "uninterpreted_option" => {
                    dec.read_repeated_into(
                        &mut self.uninterpreted_option,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                __name if __name.starts_with('[') => {
                    for __r in dec
                        .read_extension(__name, "google.protobuf.EnumValueOptions")?
                    {
                        self.__buffa_unknown_fields.push(__r);
                    }
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl<'de> serde::Deserialize<'de> for EnumValueOptions {
    fn deserialize<D: serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl<'de> serde::de::Visitor<'de> for _V {
            type Value = EnumValueOptions;
            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                f.write_str("struct EnumValueOptions")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<EnumValueOptions, A::Error> {
                let mut __f_deprecated: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_features: ::core::option::Option<
                    ::buffa::MessageField<FeatureSet, ::buffa::Inline<FeatureSet>>,
                > = None;
                let mut __f_debug_redact: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_feature_support: ::core::option::Option<
                    ::buffa::MessageField<
                        field_options::FeatureSupport,
                        ::buffa::Inline<field_options::FeatureSupport>,
                    >,
                > = None;
                let mut __f_uninterpreted_option: ::core::option::Option<
                    ::buffa::alloc::vec::Vec<UninterpretedOption>,
                > = None;
                let mut __ext_records: ::buffa::alloc::vec::Vec<::buffa::UnknownField> = ::buffa::alloc::vec::Vec::new();
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "deprecated" => {
                            __f_deprecated = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "features" => {
                            __f_features = Some(
                                map
                                    .next_value::<
                                        ::buffa::MessageField<
                                            FeatureSet,
                                            ::buffa::Inline<FeatureSet>,
                                        >,
                                    >()?,
                            );
                        }
                        "debugRedact" | "debug_redact" => {
                            __f_debug_redact = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "featureSupport" | "feature_support" => {
                            __f_feature_support = Some(
                                map
                                    .next_value::<
                                        ::buffa::MessageField<
                                            field_options::FeatureSupport,
                                            ::buffa::Inline<field_options::FeatureSupport>,
                                        >,
                                    >()?,
                            );
                        }
                        "uninterpretedOption" | "uninterpreted_option" => {
                            __f_uninterpreted_option = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::buffa::alloc::vec::Vec<UninterpretedOption>;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::buffa::alloc::vec::Vec<UninterpretedOption>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::null_as_default(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        __k if __k.starts_with('[') => {
                            let __v: ::buffa::serde_json::Value = map.next_value()?;
                            match ::buffa::extension_registry::deserialize_extension_key(
                                "google.protobuf.EnumValueOptions",
                                __k,
                                __v,
                            ) {
                                ::core::option::Option::Some(
                                    ::core::result::Result::Ok(__recs),
                                ) => {
                                    for __rec in __recs {
                                        __ext_records.push(__rec);
                                    }
                                }
                                ::core::option::Option::Some(
                                    ::core::result::Result::Err(__e),
                                ) => {
                                    return ::core::result::Result::Err(
                                        <A::Error as ::serde::de::Error>::custom(__e),
                                    );
                                }
                                ::core::option::Option::None => {}
                            }
                        }
                        _ => {
                            map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                let mut __r = <EnumValueOptions as ::core::default::Default>::default();
                if let ::core::option::Option::Some(v) = __f_deprecated {
                    __r.deprecated = v;
                }
                if let ::core::option::Option::Some(v) = __f_features {
                    __r.features = v;
                }
                if let ::core::option::Option::Some(v) = __f_debug_redact {
                    __r.debug_redact = v;
                }
                if let ::core::option::Option::Some(v) = __f_feature_support {
                    __r.feature_support = v;
                }
                if let ::core::option::Option::Some(v) = __f_uninterpreted_option {
                    __r.uninterpreted_option = v;
                }
                for __rec in __ext_records {
                    __r.__buffa_unknown_fields.push(__rec);
                }
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for EnumValueOptions {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
#[derive(Clone, Debug, Default, PartialEq)]
#[repr(transparent)]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct __EnumValueOptionsExtJson(pub ::buffa::UnknownFields);
impl ::core::ops::Deref for __EnumValueOptionsExtJson {
    type Target = ::buffa::UnknownFields;
    fn deref(&self) -> &::buffa::UnknownFields {
        &self.0
    }
}
impl ::core::ops::DerefMut for __EnumValueOptionsExtJson {
    fn deref_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.0
    }
}
impl ::core::convert::From<::buffa::UnknownFields> for __EnumValueOptionsExtJson {
    fn from(u: ::buffa::UnknownFields) -> Self {
        Self(u)
    }
}
#[cfg(feature = "json")]
impl ::serde::Serialize for __EnumValueOptionsExtJson {
    fn serialize<S: ::serde::Serializer>(
        &self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::buffa::extension_registry::serialize_extensions(
            "google.protobuf.EnumValueOptions",
            &self.0,
            s,
        )
    }
}
#[cfg(feature = "json")]
impl<'de> ::serde::Deserialize<'de> for __EnumValueOptionsExtJson {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        ::buffa::extension_registry::deserialize_extensions(
                "google.protobuf.EnumValueOptions",
                d,
            )
            .map(Self)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __ENUM_VALUE_OPTIONS_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.EnumValueOptions",
    to_json: ::buffa::type_registry::any_to_json::<EnumValueOptions>,
    from_json: ::buffa::type_registry::any_from_json::<EnumValueOptions>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __ENUM_VALUE_OPTIONS_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.EnumValueOptions",
    text_encode: ::buffa::type_registry::any_encode_text::<EnumValueOptions>,
    text_merge: ::buffa::type_registry::any_merge_text::<EnumValueOptions>,
};
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct ServiceOptions {
    /// Any features defined in the specific edition.
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    ///
    /// Field 34: `features`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "features",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub features: ::buffa::MessageField<FeatureSet, ::buffa::Inline<FeatureSet>>,
    /// Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
    ///   framework.  We apologize for hoarding these numbers to ourselves, but
    ///   we were already using them long before we decided to release Protocol
    ///   Buffers.
    ///
    /// Is this service deprecated?
    /// Depending on the target platform, this can emit Deprecated annotations
    /// for the service, or it will be completely ignored; in the very least,
    /// this is a formalization for deprecating services.
    ///
    /// Field 33: `deprecated`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "deprecated",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub deprecated: ::core::option::Option<bool>,
    /// The parser stores options it doesn't recognize here. See above.
    ///
    /// Field 999: `uninterpreted_option`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "uninterpretedOption",
            alias = "uninterpreted_option",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub uninterpreted_option: ::buffa::alloc::vec::Vec<UninterpretedOption>,
    #[cfg_attr(feature = "json", serde(flatten))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: __ServiceOptionsExtJson,
}
impl ::core::fmt::Debug for ServiceOptions {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ServiceOptions")
            .field("features", &self.features)
            .field("deprecated", &self.deprecated)
            .field("uninterpreted_option", &self.uninterpreted_option)
            .finish()
    }
}
impl ServiceOptions {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.ServiceOptions";
}
impl ServiceOptions {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::deprecated`] to `Some(value)`, consuming and returning `self`.
    pub fn with_deprecated(mut self, value: bool) -> Self {
        self.deprecated = Some(value);
        self
    }
}
::buffa::impl_default_instance!(ServiceOptions);
impl ::buffa::MessageName for ServiceOptions {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "ServiceOptions";
    const FULL_NAME: &'static str = "google.protobuf.ServiceOptions";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.ServiceOptions";
}
impl ::buffa::Message for ServiceOptions {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if self.deprecated.is_some() {
            size += 2u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if self.features.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.features.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 2u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.uninterpreted_option {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 2u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let Some(v) = self.deprecated {
            ::buffa::types::put_bool_field(33u32, v, buf);
        }
        if self.features.is_set() {
            ::buffa::types::put_len_delimited_header(
                34u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.features.write_to(__cache, buf);
        }
        for v in &self.uninterpreted_option {
            ::buffa::types::put_len_delimited_header(
                999u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            33u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.deprecated = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            34u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.features.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            999u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.uninterpreted_option.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.deprecated = ::core::option::Option::None;
        self.features = ::buffa::MessageField::none();
        self.uninterpreted_option.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ServiceOptions {
    const PROTO_FQN: &'static str = "google.protobuf.ServiceOptions";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for ServiceOptions {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.features.is_set() {
            enc.write_field_name("features")?;
            enc.write_message(&*self.features)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.deprecated {
            enc.write_field_name("deprecated")?;
            enc.write_bool(*__v)?;
        }
        for __v in &self.uninterpreted_option {
            enc.write_field_name("uninterpreted_option")?;
            enc.write_message(__v)?;
        }
        enc.write_extension_fields(
            "google.protobuf.ServiceOptions",
            &self.__buffa_unknown_fields,
        )?;
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "features" => dec.merge_message(self.features.get_or_insert_default())?,
                "deprecated" => {
                    self.deprecated = ::core::option::Option::Some(dec.read_bool()?);
                }
                "uninterpreted_option" => {
                    dec.read_repeated_into(
                        &mut self.uninterpreted_option,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                __name if __name.starts_with('[') => {
                    for __r in dec
                        .read_extension(__name, "google.protobuf.ServiceOptions")?
                    {
                        self.__buffa_unknown_fields.push(__r);
                    }
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl<'de> serde::Deserialize<'de> for ServiceOptions {
    fn deserialize<D: serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl<'de> serde::de::Visitor<'de> for _V {
            type Value = ServiceOptions;
            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                f.write_str("struct ServiceOptions")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<ServiceOptions, A::Error> {
                let mut __f_features: ::core::option::Option<
                    ::buffa::MessageField<FeatureSet, ::buffa::Inline<FeatureSet>>,
                > = None;
                let mut __f_deprecated: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_uninterpreted_option: ::core::option::Option<
                    ::buffa::alloc::vec::Vec<UninterpretedOption>,
                > = None;
                let mut __ext_records: ::buffa::alloc::vec::Vec<::buffa::UnknownField> = ::buffa::alloc::vec::Vec::new();
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "features" => {
                            __f_features = Some(
                                map
                                    .next_value::<
                                        ::buffa::MessageField<
                                            FeatureSet,
                                            ::buffa::Inline<FeatureSet>,
                                        >,
                                    >()?,
                            );
                        }
                        "deprecated" => {
                            __f_deprecated = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "uninterpretedOption" | "uninterpreted_option" => {
                            __f_uninterpreted_option = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::buffa::alloc::vec::Vec<UninterpretedOption>;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::buffa::alloc::vec::Vec<UninterpretedOption>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::null_as_default(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        __k if __k.starts_with('[') => {
                            let __v: ::buffa::serde_json::Value = map.next_value()?;
                            match ::buffa::extension_registry::deserialize_extension_key(
                                "google.protobuf.ServiceOptions",
                                __k,
                                __v,
                            ) {
                                ::core::option::Option::Some(
                                    ::core::result::Result::Ok(__recs),
                                ) => {
                                    for __rec in __recs {
                                        __ext_records.push(__rec);
                                    }
                                }
                                ::core::option::Option::Some(
                                    ::core::result::Result::Err(__e),
                                ) => {
                                    return ::core::result::Result::Err(
                                        <A::Error as ::serde::de::Error>::custom(__e),
                                    );
                                }
                                ::core::option::Option::None => {}
                            }
                        }
                        _ => {
                            map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                let mut __r = <ServiceOptions as ::core::default::Default>::default();
                if let ::core::option::Option::Some(v) = __f_features {
                    __r.features = v;
                }
                if let ::core::option::Option::Some(v) = __f_deprecated {
                    __r.deprecated = v;
                }
                if let ::core::option::Option::Some(v) = __f_uninterpreted_option {
                    __r.uninterpreted_option = v;
                }
                for __rec in __ext_records {
                    __r.__buffa_unknown_fields.push(__rec);
                }
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for ServiceOptions {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
#[derive(Clone, Debug, Default, PartialEq)]
#[repr(transparent)]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct __ServiceOptionsExtJson(pub ::buffa::UnknownFields);
impl ::core::ops::Deref for __ServiceOptionsExtJson {
    type Target = ::buffa::UnknownFields;
    fn deref(&self) -> &::buffa::UnknownFields {
        &self.0
    }
}
impl ::core::ops::DerefMut for __ServiceOptionsExtJson {
    fn deref_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.0
    }
}
impl ::core::convert::From<::buffa::UnknownFields> for __ServiceOptionsExtJson {
    fn from(u: ::buffa::UnknownFields) -> Self {
        Self(u)
    }
}
#[cfg(feature = "json")]
impl ::serde::Serialize for __ServiceOptionsExtJson {
    fn serialize<S: ::serde::Serializer>(
        &self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::buffa::extension_registry::serialize_extensions(
            "google.protobuf.ServiceOptions",
            &self.0,
            s,
        )
    }
}
#[cfg(feature = "json")]
impl<'de> ::serde::Deserialize<'de> for __ServiceOptionsExtJson {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        ::buffa::extension_registry::deserialize_extensions(
                "google.protobuf.ServiceOptions",
                d,
            )
            .map(Self)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __SERVICE_OPTIONS_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.ServiceOptions",
    to_json: ::buffa::type_registry::any_to_json::<ServiceOptions>,
    from_json: ::buffa::type_registry::any_from_json::<ServiceOptions>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __SERVICE_OPTIONS_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.ServiceOptions",
    text_encode: ::buffa::type_registry::any_encode_text::<ServiceOptions>,
    text_merge: ::buffa::type_registry::any_merge_text::<ServiceOptions>,
};
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct MethodOptions {
    /// Note:  Field numbers 1 through 32 are reserved for Google's internal RPC
    ///   framework.  We apologize for hoarding these numbers to ourselves, but
    ///   we were already using them long before we decided to release Protocol
    ///   Buffers.
    ///
    /// Is this method deprecated?
    /// Depending on the target platform, this can emit Deprecated annotations
    /// for the method, or it will be completely ignored; in the very least,
    /// this is a formalization for deprecating methods.
    ///
    /// Field 33: `deprecated`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "deprecated",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub deprecated: ::core::option::Option<bool>,
    /// Field 34: `idempotency_level`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "idempotencyLevel",
            alias = "idempotency_level",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub idempotency_level: ::core::option::Option<method_options::IdempotencyLevel>,
    /// Any features defined in the specific edition.
    /// WARNING: This field should only be used by protobuf plugins or special
    /// cases like the proto compiler. Other uses are discouraged and
    /// developers should rely on the protoreflect APIs for their client language.
    ///
    /// Field 35: `features`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "features",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
        )
    )]
    pub features: ::buffa::MessageField<FeatureSet, ::buffa::Inline<FeatureSet>>,
    /// The parser stores options it doesn't recognize here. See above.
    ///
    /// Field 999: `uninterpreted_option`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "uninterpretedOption",
            alias = "uninterpreted_option",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub uninterpreted_option: ::buffa::alloc::vec::Vec<UninterpretedOption>,
    #[cfg_attr(feature = "json", serde(flatten))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: __MethodOptionsExtJson,
}
impl ::core::fmt::Debug for MethodOptions {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("MethodOptions")
            .field("deprecated", &self.deprecated)
            .field("idempotency_level", &self.idempotency_level)
            .field("features", &self.features)
            .field("uninterpreted_option", &self.uninterpreted_option)
            .finish()
    }
}
impl MethodOptions {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.MethodOptions";
}
impl MethodOptions {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::deprecated`] to `Some(value)`, consuming and returning `self`.
    pub fn with_deprecated(mut self, value: bool) -> Self {
        self.deprecated = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::idempotency_level`] to `Some(value)`, consuming and returning `self`.
    pub fn with_idempotency_level(
        mut self,
        value: impl Into<method_options::IdempotencyLevel>,
    ) -> Self {
        self.idempotency_level = Some(value.into());
        self
    }
}
::buffa::impl_default_instance!(MethodOptions);
impl ::buffa::MessageName for MethodOptions {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "MethodOptions";
    const FULL_NAME: &'static str = "google.protobuf.MethodOptions";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.MethodOptions";
}
impl ::buffa::Message for MethodOptions {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if self.deprecated.is_some() {
            size += 2u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if let Some(ref v) = self.idempotency_level {
            size += 2u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        if self.features.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.features.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 2u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        for v in &self.uninterpreted_option {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 2u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let Some(v) = self.deprecated {
            ::buffa::types::put_bool_field(33u32, v, buf);
        }
        if let Some(ref v) = self.idempotency_level {
            ::buffa::types::put_int32_field(34u32, v.to_i32(), buf);
        }
        if self.features.is_set() {
            ::buffa::types::put_len_delimited_header(
                35u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.features.write_to(__cache, buf);
        }
        for v in &self.uninterpreted_option {
            ::buffa::types::put_len_delimited_header(
                999u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            33u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.deprecated = ::core::option::Option::Some(
                    ::buffa::types::decode_bool(buf)?,
                );
            }
            34u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.idempotency_level = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 34u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            35u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.features.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            999u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.uninterpreted_option.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.deprecated = ::core::option::Option::None;
        self.idempotency_level = ::core::option::Option::None;
        self.features = ::buffa::MessageField::none();
        self.uninterpreted_option.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for MethodOptions {
    const PROTO_FQN: &'static str = "google.protobuf.MethodOptions";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for MethodOptions {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref __v) = self.deprecated {
            enc.write_field_name("deprecated")?;
            enc.write_bool(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.idempotency_level {
            enc.write_field_name("idempotency_level")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        if self.features.is_set() {
            enc.write_field_name("features")?;
            enc.write_message(&*self.features)?;
        }
        for __v in &self.uninterpreted_option {
            enc.write_field_name("uninterpreted_option")?;
            enc.write_message(__v)?;
        }
        enc.write_extension_fields(
            "google.protobuf.MethodOptions",
            &self.__buffa_unknown_fields,
        )?;
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "deprecated" => {
                    self.deprecated = ::core::option::Option::Some(dec.read_bool()?);
                }
                "idempotency_level" => {
                    self.idempotency_level = ::core::option::Option::Some(
                        dec
                            .read_closed_enum_by_name::<
                                method_options::IdempotencyLevel,
                            >()?,
                    );
                }
                "features" => dec.merge_message(self.features.get_or_insert_default())?,
                "uninterpreted_option" => {
                    dec.read_repeated_into(
                        &mut self.uninterpreted_option,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                __name if __name.starts_with('[') => {
                    for __r in dec
                        .read_extension(__name, "google.protobuf.MethodOptions")?
                    {
                        self.__buffa_unknown_fields.push(__r);
                    }
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl<'de> serde::Deserialize<'de> for MethodOptions {
    fn deserialize<D: serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl<'de> serde::de::Visitor<'de> for _V {
            type Value = MethodOptions;
            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                f.write_str("struct MethodOptions")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<MethodOptions, A::Error> {
                let mut __f_deprecated: ::core::option::Option<
                    ::core::option::Option<bool>,
                > = None;
                let mut __f_idempotency_level: ::core::option::Option<
                    ::core::option::Option<method_options::IdempotencyLevel>,
                > = None;
                let mut __f_features: ::core::option::Option<
                    ::buffa::MessageField<FeatureSet, ::buffa::Inline<FeatureSet>>,
                > = None;
                let mut __f_uninterpreted_option: ::core::option::Option<
                    ::buffa::alloc::vec::Vec<UninterpretedOption>,
                > = None;
                let mut __ext_records: ::buffa::alloc::vec::Vec<::buffa::UnknownField> = ::buffa::alloc::vec::Vec::new();
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "deprecated" => {
                            __f_deprecated = Some(
                                map.next_value::<::core::option::Option<bool>>()?,
                            );
                        }
                        "idempotencyLevel" | "idempotency_level" => {
                            __f_idempotency_level = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::core::option::Option<
                                        method_options::IdempotencyLevel,
                                    >;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::core::option::Option<method_options::IdempotencyLevel>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::opt_closed_enum::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "features" => {
                            __f_features = Some(
                                map
                                    .next_value::<
                                        ::buffa::MessageField<
                                            FeatureSet,
                                            ::buffa::Inline<FeatureSet>,
                                        >,
                                    >()?,
                            );
                        }
                        "uninterpretedOption" | "uninterpreted_option" => {
                            __f_uninterpreted_option = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::buffa::alloc::vec::Vec<UninterpretedOption>;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::buffa::alloc::vec::Vec<UninterpretedOption>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::null_as_default(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        __k if __k.starts_with('[') => {
                            let __v: ::buffa::serde_json::Value = map.next_value()?;
                            match ::buffa::extension_registry::deserialize_extension_key(
                                "google.protobuf.MethodOptions",
                                __k,
                                __v,
                            ) {
                                ::core::option::Option::Some(
                                    ::core::result::Result::Ok(__recs),
                                ) => {
                                    for __rec in __recs {
                                        __ext_records.push(__rec);
                                    }
                                }
                                ::core::option::Option::Some(
                                    ::core::result::Result::Err(__e),
                                ) => {
                                    return ::core::result::Result::Err(
                                        <A::Error as ::serde::de::Error>::custom(__e),
                                    );
                                }
                                ::core::option::Option::None => {}
                            }
                        }
                        _ => {
                            map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                let mut __r = <MethodOptions as ::core::default::Default>::default();
                if let ::core::option::Option::Some(v) = __f_deprecated {
                    __r.deprecated = v;
                }
                if let ::core::option::Option::Some(v) = __f_idempotency_level {
                    __r.idempotency_level = v;
                }
                if let ::core::option::Option::Some(v) = __f_features {
                    __r.features = v;
                }
                if let ::core::option::Option::Some(v) = __f_uninterpreted_option {
                    __r.uninterpreted_option = v;
                }
                for __rec in __ext_records {
                    __r.__buffa_unknown_fields.push(__rec);
                }
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for MethodOptions {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
#[derive(Clone, Debug, Default, PartialEq)]
#[repr(transparent)]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct __MethodOptionsExtJson(pub ::buffa::UnknownFields);
impl ::core::ops::Deref for __MethodOptionsExtJson {
    type Target = ::buffa::UnknownFields;
    fn deref(&self) -> &::buffa::UnknownFields {
        &self.0
    }
}
impl ::core::ops::DerefMut for __MethodOptionsExtJson {
    fn deref_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.0
    }
}
impl ::core::convert::From<::buffa::UnknownFields> for __MethodOptionsExtJson {
    fn from(u: ::buffa::UnknownFields) -> Self {
        Self(u)
    }
}
#[cfg(feature = "json")]
impl ::serde::Serialize for __MethodOptionsExtJson {
    fn serialize<S: ::serde::Serializer>(
        &self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::buffa::extension_registry::serialize_extensions(
            "google.protobuf.MethodOptions",
            &self.0,
            s,
        )
    }
}
#[cfg(feature = "json")]
impl<'de> ::serde::Deserialize<'de> for __MethodOptionsExtJson {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        ::buffa::extension_registry::deserialize_extensions(
                "google.protobuf.MethodOptions",
                d,
            )
            .map(Self)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __METHOD_OPTIONS_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.MethodOptions",
    to_json: ::buffa::type_registry::any_to_json::<MethodOptions>,
    from_json: ::buffa::type_registry::any_from_json::<MethodOptions>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __METHOD_OPTIONS_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.MethodOptions",
    text_encode: ::buffa::type_registry::any_encode_text::<MethodOptions>,
    text_merge: ::buffa::type_registry::any_merge_text::<MethodOptions>,
};
pub mod method_options {
    #[allow(unused_imports)]
    use super::*;
    /// Is this method side-effect-free (or safe in HTTP parlance), or idempotent,
    /// or neither? HTTP based RPC implementation may choose GET verb for safe
    /// methods, and PUT verb for idempotent methods instead of the default POST.
    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    #[repr(i32)]
    pub enum IdempotencyLevel {
        IDEMPOTENCY_UNKNOWN = 0i32,
        /// implies idempotent
        NO_SIDE_EFFECTS = 1i32,
        /// idempotent, but may have side effects
        IDEMPOTENT = 2i32,
    }
    impl IdempotencyLevel {
        ///Idiomatic alias for [`Self::IDEMPOTENCY_UNKNOWN`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const IdempotencyUnknown: Self = Self::IDEMPOTENCY_UNKNOWN;
        ///Idiomatic alias for [`Self::NO_SIDE_EFFECTS`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const NoSideEffects: Self = Self::NO_SIDE_EFFECTS;
        ///Idiomatic alias for [`Self::IDEMPOTENT`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Idempotent: Self = Self::IDEMPOTENT;
    }
    impl ::core::default::Default for IdempotencyLevel {
        fn default() -> Self {
            Self::IDEMPOTENCY_UNKNOWN
        }
    }
    #[cfg(feature = "json")]
    const _: () = {
        impl ::serde::Serialize for IdempotencyLevel {
            fn serialize<S: ::serde::Serializer>(
                &self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                s.serialize_str(::buffa::Enumeration::proto_name(self))
            }
        }
        impl<'de> ::serde::Deserialize<'de> for IdempotencyLevel {
            fn deserialize<D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                struct _V;
                impl ::serde::de::Visitor<'_> for _V {
                    type Value = IdempotencyLevel;
                    fn expecting(
                        &self,
                        f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        f.write_str(
                            concat!(
                                "a string, integer, or null for ",
                                stringify!(IdempotencyLevel)
                            ),
                        )
                    }
                    fn visit_str<E: ::serde::de::Error>(
                        self,
                        v: &str,
                    ) -> ::core::result::Result<IdempotencyLevel, E> {
                        <IdempotencyLevel as ::buffa::Enumeration>::from_proto_name(v)
                            .ok_or_else(|| {
                                ::serde::de::Error::unknown_variant(v, &[])
                            })
                    }
                    fn visit_i64<E: ::serde::de::Error>(
                        self,
                        v: i64,
                    ) -> ::core::result::Result<IdempotencyLevel, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <IdempotencyLevel as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_u64<E: ::serde::de::Error>(
                        self,
                        v: u64,
                    ) -> ::core::result::Result<IdempotencyLevel, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <IdempotencyLevel as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_unit<E: ::serde::de::Error>(
                        self,
                    ) -> ::core::result::Result<IdempotencyLevel, E> {
                        ::core::result::Result::Ok(::core::default::Default::default())
                    }
                }
                d.deserialize_any(_V)
            }
        }
        impl ::buffa::json_helpers::ProtoElemJson for IdempotencyLevel {
            fn serialize_proto_json<S: ::serde::Serializer>(
                v: &Self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                ::serde::Serialize::serialize(v, s)
            }
            fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                <Self as ::serde::Deserialize>::deserialize(d)
            }
        }
    };
    impl ::buffa::Enumeration for IdempotencyLevel {
        fn from_i32(value: i32) -> ::core::option::Option<Self> {
            match value {
                0i32 => ::core::option::Option::Some(Self::IDEMPOTENCY_UNKNOWN),
                1i32 => ::core::option::Option::Some(Self::NO_SIDE_EFFECTS),
                2i32 => ::core::option::Option::Some(Self::IDEMPOTENT),
                _ => ::core::option::Option::None,
            }
        }
        fn to_i32(&self) -> i32 {
            *self as i32
        }
        fn proto_name(&self) -> &'static str {
            match self {
                Self::IDEMPOTENCY_UNKNOWN => "IDEMPOTENCY_UNKNOWN",
                Self::NO_SIDE_EFFECTS => "NO_SIDE_EFFECTS",
                Self::IDEMPOTENT => "IDEMPOTENT",
            }
        }
        fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
            match name {
                "IDEMPOTENCY_UNKNOWN" => {
                    ::core::option::Option::Some(Self::IDEMPOTENCY_UNKNOWN)
                }
                "NO_SIDE_EFFECTS" => ::core::option::Option::Some(Self::NO_SIDE_EFFECTS),
                "IDEMPOTENT" => ::core::option::Option::Some(Self::IDEMPOTENT),
                _ => ::core::option::Option::None,
            }
        }
        fn values() -> &'static [Self] {
            &[Self::IDEMPOTENCY_UNKNOWN, Self::NO_SIDE_EFFECTS, Self::IDEMPOTENT]
        }
    }
}
/// A message representing a option the parser does not recognize. This only
/// appears in options protos created by the compiler::Parser class.
/// DescriptorPool resolves these when building Descriptor objects. Therefore,
/// options protos in descriptor objects (e.g. returned by Descriptor::options(),
/// or produced by Descriptor::CopyTo()) will never have UninterpretedOptions
/// in them.
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct UninterpretedOption {
    /// Field 2: `name`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "name",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub name: ::buffa::alloc::vec::Vec<uninterpreted_option::NamePart>,
    /// The value of the uninterpreted option, in whatever type the tokenizer
    /// identified it as during parsing. Exactly one of these should be set.
    ///
    /// Field 3: `identifier_value`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "identifierValue",
            alias = "identifier_value",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub identifier_value: ::core::option::Option<::buffa::alloc::string::String>,
    /// Field 4: `positive_int_value`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "positiveIntValue",
            alias = "positive_int_value",
            with = "::buffa::json_helpers::opt_uint64",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub positive_int_value: ::core::option::Option<u64>,
    /// Field 5: `negative_int_value`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "negativeIntValue",
            alias = "negative_int_value",
            with = "::buffa::json_helpers::opt_int64",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub negative_int_value: ::core::option::Option<i64>,
    /// Field 6: `double_value`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "doubleValue",
            alias = "double_value",
            with = "::buffa::json_helpers::opt_double",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub double_value: ::core::option::Option<f64>,
    /// Field 7: `string_value`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "stringValue",
            alias = "string_value",
            with = "::buffa::json_helpers::opt_bytes",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub string_value: ::core::option::Option<::buffa::alloc::vec::Vec<u8>>,
    /// Field 8: `aggregate_value`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "aggregateValue",
            alias = "aggregate_value",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub aggregate_value: ::core::option::Option<::buffa::alloc::string::String>,
    #[cfg_attr(feature = "json", serde(skip))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for UninterpretedOption {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("UninterpretedOption")
            .field("name", &self.name)
            .field("identifier_value", &self.identifier_value)
            .field("positive_int_value", &self.positive_int_value)
            .field("negative_int_value", &self.negative_int_value)
            .field("double_value", &self.double_value)
            .field("string_value", &self.string_value)
            .field("aggregate_value", &self.aggregate_value)
            .finish()
    }
}
impl UninterpretedOption {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.UninterpretedOption";
}
impl UninterpretedOption {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::identifier_value`] to `Some(value)`, consuming and returning `self`.
    pub fn with_identifier_value(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.identifier_value = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::positive_int_value`] to `Some(value)`, consuming and returning `self`.
    pub fn with_positive_int_value(mut self, value: u64) -> Self {
        self.positive_int_value = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::negative_int_value`] to `Some(value)`, consuming and returning `self`.
    pub fn with_negative_int_value(mut self, value: i64) -> Self {
        self.negative_int_value = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::double_value`] to `Some(value)`, consuming and returning `self`.
    pub fn with_double_value(mut self, value: f64) -> Self {
        self.double_value = Some(value);
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::string_value`] to `Some(value)`, consuming and returning `self`.
    pub fn with_string_value(
        mut self,
        value: impl Into<::buffa::alloc::vec::Vec<u8>>,
    ) -> Self {
        self.string_value = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::aggregate_value`] to `Some(value)`, consuming and returning `self`.
    pub fn with_aggregate_value(
        mut self,
        value: impl Into<::buffa::alloc::string::String>,
    ) -> Self {
        self.aggregate_value = Some(value.into());
        self
    }
}
::buffa::impl_default_instance!(UninterpretedOption);
impl ::buffa::MessageName for UninterpretedOption {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "UninterpretedOption";
    const FULL_NAME: &'static str = "google.protobuf.UninterpretedOption";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.UninterpretedOption";
}
impl ::buffa::Message for UninterpretedOption {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        for v in &self.name {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if let Some(ref v) = self.identifier_value {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        if let Some(v) = self.positive_int_value {
            size += 1u64 + ::buffa::types::uint64_encoded_len(v) as u64;
        }
        if let Some(v) = self.negative_int_value {
            size += 1u64 + ::buffa::types::int64_encoded_len(v) as u64;
        }
        if self.double_value.is_some() {
            size += 1u64 + ::buffa::types::FIXED64_ENCODED_LEN as u64;
        }
        if let Some(ref v) = self.string_value {
            size += 1u64 + ::buffa::types::bytes_encoded_len(v) as u64;
        }
        if let Some(ref v) = self.aggregate_value {
            size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for v in &self.name {
            ::buffa::types::put_len_delimited_header(
                2u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        if let Some(ref v) = self.identifier_value {
            ::buffa::types::put_string_field(3u32, v, buf);
        }
        if let Some(v) = self.positive_int_value {
            ::buffa::types::put_uint64_field(4u32, v, buf);
        }
        if let Some(v) = self.negative_int_value {
            ::buffa::types::put_int64_field(5u32, v, buf);
        }
        if let Some(v) = self.double_value {
            ::buffa::types::put_double_field(6u32, v, buf);
        }
        if let Some(ref v) = self.string_value {
            ::buffa::types::put_shared_bytes_field(7u32, v, buf);
        }
        if let Some(ref v) = self.aggregate_value {
            ::buffa::types::put_string_field(8u32, v, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.name.push(elem);
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self
                        .identifier_value
                        .get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.positive_int_value = ::core::option::Option::Some(
                    ::buffa::types::decode_uint64(buf)?,
                );
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.negative_int_value = ::core::option::Option::Some(
                    ::buffa::types::decode_int64(buf)?,
                );
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Fixed64,
                )?;
                self.double_value = ::core::option::Option::Some(
                    ::buffa::types::decode_double(buf)?,
                );
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_bytes(
                    self.string_value.get_or_insert_with(::buffa::alloc::vec::Vec::new),
                    buf,
                )?;
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(
                    self
                        .aggregate_value
                        .get_or_insert_with(::buffa::alloc::string::String::new),
                    buf,
                )?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.name.clear();
        self.identifier_value = ::core::option::Option::None;
        self.positive_int_value = ::core::option::Option::None;
        self.negative_int_value = ::core::option::Option::None;
        self.double_value = ::core::option::Option::None;
        self.string_value = ::core::option::Option::None;
        self.aggregate_value = ::core::option::Option::None;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for UninterpretedOption {
    const PROTO_FQN: &'static str = "google.protobuf.UninterpretedOption";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for UninterpretedOption {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref __v) = self.identifier_value {
            enc.write_field_name("identifier_value")?;
            enc.write_string(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.positive_int_value {
            enc.write_field_name("positive_int_value")?;
            enc.write_u64(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.negative_int_value {
            enc.write_field_name("negative_int_value")?;
            enc.write_i64(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.double_value {
            enc.write_field_name("double_value")?;
            enc.write_f64(*__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.string_value {
            enc.write_field_name("string_value")?;
            enc.write_bytes(__v)?;
        }
        if let ::core::option::Option::Some(ref __v) = self.aggregate_value {
            enc.write_field_name("aggregate_value")?;
            enc.write_string(__v)?;
        }
        for __v in &self.name {
            enc.write_field_name("name")?;
            enc.write_message(__v)?;
        }
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "identifier_value" => {
                    self.identifier_value = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "positive_int_value" => {
                    self.positive_int_value = ::core::option::Option::Some(
                        dec.read_u64()?,
                    );
                }
                "negative_int_value" => {
                    self.negative_int_value = ::core::option::Option::Some(
                        dec.read_i64()?,
                    );
                }
                "double_value" => {
                    self.double_value = ::core::option::Option::Some(dec.read_f64()?);
                }
                "string_value" => {
                    self.string_value = ::core::option::Option::Some(dec.read_bytes()?);
                }
                "aggregate_value" => {
                    self.aggregate_value = ::core::option::Option::Some(
                        dec.read_string()?.into_owned(),
                    );
                }
                "name" => {
                    dec.read_repeated_into(
                        &mut self.name,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for UninterpretedOption {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __UNINTERPRETED_OPTION_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.UninterpretedOption",
    to_json: ::buffa::type_registry::any_to_json::<UninterpretedOption>,
    from_json: ::buffa::type_registry::any_from_json::<UninterpretedOption>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __UNINTERPRETED_OPTION_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.UninterpretedOption",
    text_encode: ::buffa::type_registry::any_encode_text::<UninterpretedOption>,
    text_merge: ::buffa::type_registry::any_merge_text::<UninterpretedOption>,
};
pub mod uninterpreted_option {
    #[allow(unused_imports)]
    use super::*;
    /// The name of the uninterpreted option.  Each string represents a segment in
    /// a dot-separated name.  is_extension is true iff a segment represents an
    /// extension (denoted with parentheses in options specs in .proto files).
    /// E.g.,{ \["foo", false\], \["bar.baz", true\], \["moo", false\] } represents
    /// "foo.(bar.baz).moo".
    #[derive(Clone, PartialEq, Default)]
    #[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
    #[cfg_attr(feature = "json", serde(default))]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    pub struct NamePart {
        /// Field 1: `name_part`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "namePart",
                alias = "name_part",
                with = "::buffa::json_helpers::proto_string"
            )
        )]
        pub name_part: ::buffa::alloc::string::String,
        /// Field 2: `is_extension`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "isExtension",
                alias = "is_extension",
                with = "::buffa::json_helpers::proto_bool"
            )
        )]
        pub is_extension: bool,
        #[cfg_attr(feature = "json", serde(skip))]
        #[doc(hidden)]
        pub __buffa_unknown_fields: ::buffa::UnknownFields,
    }
    impl ::core::fmt::Debug for NamePart {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            f.debug_struct("NamePart")
                .field("name_part", &self.name_part)
                .field("is_extension", &self.is_extension)
                .finish()
        }
    }
    impl NamePart {
        /// Protobuf type URL for this message, for use with `Any::pack` and
        /// `Any::unpack_if`.
        ///
        /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
        pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.UninterpretedOption.NamePart";
    }
    ::buffa::impl_default_instance!(NamePart);
    impl ::buffa::MessageName for NamePart {
        const PACKAGE: &'static str = "google.protobuf";
        const NAME: &'static str = "UninterpretedOption.NamePart";
        const FULL_NAME: &'static str = "google.protobuf.UninterpretedOption.NamePart";
        const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.UninterpretedOption.NamePart";
    }
    impl ::buffa::Message for NamePart {
        /// Returns the total encoded size in bytes.
        ///
        /// Accumulates in `u64` (which cannot overflow for in-memory
        /// data) and saturates to `u32` at return, so a message whose
        /// encoded size exceeds the 2 GiB protobuf limit yields a value
        /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
        /// points reject, never a silently wrapped size.
        #[allow(clippy::let_and_return)]
        fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            let mut size = 0u64;
            size += 1u64 + ::buffa::types::string_encoded_len(&self.name_part) as u64;
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
            size += self.__buffa_unknown_fields.encoded_len() as u64;
            ::buffa::saturate_size(size)
        }
        fn write_to(
            &self,
            _cache: &mut ::buffa::SizeCache,
            buf: &mut impl ::buffa::EncodeSink,
        ) {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            ::buffa::types::put_string_field(1u32, &self.name_part, buf);
            ::buffa::types::put_bool_field(2u32, self.is_extension, buf);
            self.__buffa_unknown_fields.write_to(buf);
        }
        fn merge_field(
            &mut self,
            tag: ::buffa::encoding::Tag,
            buf: &mut impl ::buffa::bytes::Buf,
            ctx: ::buffa::DecodeContext<'_>,
        ) -> ::core::result::Result<(), ::buffa::DecodeError> {
            #[allow(unused_imports)]
            use ::buffa::bytes::Buf as _;
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            match tag.field_number() {
                1u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::LengthDelimited,
                    )?;
                    ::buffa::types::merge_string(&mut self.name_part, buf)?;
                }
                2u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::Varint,
                    )?;
                    self.is_extension = ::buffa::types::decode_bool(buf)?;
                }
                _ => {
                    self.__buffa_unknown_fields
                        .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
                }
            }
            ::core::result::Result::Ok(())
        }
        fn clear(&mut self) {
            self.name_part.clear();
            self.is_extension = false;
            self.__buffa_unknown_fields.clear();
        }
    }
    impl ::buffa::ExtensionSet for NamePart {
        const PROTO_FQN: &'static str = "google.protobuf.UninterpretedOption.NamePart";
        fn unknown_fields(&self) -> &::buffa::UnknownFields {
            &self.__buffa_unknown_fields
        }
        fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
            &mut self.__buffa_unknown_fields
        }
    }
    #[cfg(feature = "text")]
    impl ::buffa::text::TextFormat for NamePart {
        fn encode_text(
            &self,
            enc: &mut ::buffa::text::TextEncoder<'_>,
        ) -> ::core::fmt::Result {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            enc.write_field_name("name_part")?;
            enc.write_string(&self.name_part)?;
            enc.write_field_name("is_extension")?;
            enc.write_bool(self.is_extension)?;
            enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
            ::core::result::Result::Ok(())
        }
        fn merge_text(
            &mut self,
            dec: &mut ::buffa::text::TextDecoder<'_>,
        ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
                match __name {
                    "name_part" => self.name_part = dec.read_string()?.into_owned(),
                    "is_extension" => self.is_extension = dec.read_bool()?,
                    _ => dec.skip_value()?,
                }
            }
            ::core::result::Result::Ok(())
        }
    }
    #[cfg(feature = "json")]
    impl ::buffa::json_helpers::ProtoElemJson for NamePart {
        fn serialize_proto_json<S: ::serde::Serializer>(
            v: &Self,
            s: S,
        ) -> ::core::result::Result<S::Ok, S::Error> {
            ::serde::Serialize::serialize(v, s)
        }
        fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
            d: D,
        ) -> ::core::result::Result<Self, D::Error> {
            <Self as ::serde::Deserialize>::deserialize(d)
        }
    }
    #[cfg(feature = "json")]
    #[doc(hidden)]
    pub const __NAME_PART_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.UninterpretedOption.NamePart",
        to_json: ::buffa::type_registry::any_to_json::<NamePart>,
        from_json: ::buffa::type_registry::any_from_json::<NamePart>,
        is_wkt: false,
    };
    #[cfg(feature = "text")]
    #[doc(hidden)]
    pub const __NAME_PART_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.UninterpretedOption.NamePart",
        text_encode: ::buffa::type_registry::any_encode_text::<NamePart>,
        text_merge: ::buffa::type_registry::any_merge_text::<NamePart>,
    };
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::uninterpreted_option::NamePartView;
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::uninterpreted_option::NamePartOwnedView;
}
/// ===================================================================
/// Features
///
/// TODO Enums in C++ gencode (and potentially other languages) are
/// not well scoped.  This means that each of the feature enums below can clash
/// with each other.  The short names we've chosen maximize call-site
/// readability, but leave us very open to this scenario.  A future feature will
/// be designed and implemented to handle this, hopefully before we ever hit a
/// conflict here.
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct FeatureSet {
    /// Field 1: `field_presence`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "fieldPresence",
            alias = "field_presence",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub field_presence: ::core::option::Option<feature_set::FieldPresence>,
    /// Field 2: `enum_type`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "enumType",
            alias = "enum_type",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub enum_type: ::core::option::Option<feature_set::EnumType>,
    /// Field 3: `repeated_field_encoding`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "repeatedFieldEncoding",
            alias = "repeated_field_encoding",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub repeated_field_encoding: ::core::option::Option<
        feature_set::RepeatedFieldEncoding,
    >,
    /// Field 4: `utf8_validation`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "utf8Validation",
            alias = "utf8_validation",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub utf8_validation: ::core::option::Option<feature_set::Utf8Validation>,
    /// Field 5: `message_encoding`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "messageEncoding",
            alias = "message_encoding",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub message_encoding: ::core::option::Option<feature_set::MessageEncoding>,
    /// Field 6: `json_format`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "jsonFormat",
            alias = "json_format",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub json_format: ::core::option::Option<feature_set::JsonFormat>,
    /// Field 7: `enforce_naming_style`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "enforceNamingStyle",
            alias = "enforce_naming_style",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub enforce_naming_style: ::core::option::Option<feature_set::EnforceNamingStyle>,
    /// Field 8: `default_symbol_visibility`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "defaultSymbolVisibility",
            alias = "default_symbol_visibility",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub default_symbol_visibility: ::core::option::Option<
        feature_set::visibility_feature::DefaultSymbolVisibility,
    >,
    #[cfg_attr(feature = "json", serde(flatten))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: __FeatureSetExtJson,
}
impl ::core::fmt::Debug for FeatureSet {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("FeatureSet")
            .field("field_presence", &self.field_presence)
            .field("enum_type", &self.enum_type)
            .field("repeated_field_encoding", &self.repeated_field_encoding)
            .field("utf8_validation", &self.utf8_validation)
            .field("message_encoding", &self.message_encoding)
            .field("json_format", &self.json_format)
            .field("enforce_naming_style", &self.enforce_naming_style)
            .field("default_symbol_visibility", &self.default_symbol_visibility)
            .finish()
    }
}
impl FeatureSet {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FeatureSet";
}
impl FeatureSet {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::field_presence`] to `Some(value)`, consuming and returning `self`.
    pub fn with_field_presence(
        mut self,
        value: impl Into<feature_set::FieldPresence>,
    ) -> Self {
        self.field_presence = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::enum_type`] to `Some(value)`, consuming and returning `self`.
    pub fn with_enum_type(mut self, value: impl Into<feature_set::EnumType>) -> Self {
        self.enum_type = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::repeated_field_encoding`] to `Some(value)`, consuming and returning `self`.
    pub fn with_repeated_field_encoding(
        mut self,
        value: impl Into<feature_set::RepeatedFieldEncoding>,
    ) -> Self {
        self.repeated_field_encoding = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::utf8_validation`] to `Some(value)`, consuming and returning `self`.
    pub fn with_utf8_validation(
        mut self,
        value: impl Into<feature_set::Utf8Validation>,
    ) -> Self {
        self.utf8_validation = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::message_encoding`] to `Some(value)`, consuming and returning `self`.
    pub fn with_message_encoding(
        mut self,
        value: impl Into<feature_set::MessageEncoding>,
    ) -> Self {
        self.message_encoding = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::json_format`] to `Some(value)`, consuming and returning `self`.
    pub fn with_json_format(
        mut self,
        value: impl Into<feature_set::JsonFormat>,
    ) -> Self {
        self.json_format = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::enforce_naming_style`] to `Some(value)`, consuming and returning `self`.
    pub fn with_enforce_naming_style(
        mut self,
        value: impl Into<feature_set::EnforceNamingStyle>,
    ) -> Self {
        self.enforce_naming_style = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::default_symbol_visibility`] to `Some(value)`, consuming and returning `self`.
    pub fn with_default_symbol_visibility(
        mut self,
        value: impl Into<feature_set::visibility_feature::DefaultSymbolVisibility>,
    ) -> Self {
        self.default_symbol_visibility = Some(value.into());
        self
    }
}
::buffa::impl_default_instance!(FeatureSet);
impl ::buffa::MessageName for FeatureSet {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "FeatureSet";
    const FULL_NAME: &'static str = "google.protobuf.FeatureSet";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FeatureSet";
}
impl ::buffa::Message for FeatureSet {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if let Some(ref v) = self.field_presence {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        if let Some(ref v) = self.enum_type {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        if let Some(ref v) = self.repeated_field_encoding {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        if let Some(ref v) = self.utf8_validation {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        if let Some(ref v) = self.message_encoding {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        if let Some(ref v) = self.json_format {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        if let Some(ref v) = self.enforce_naming_style {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        if let Some(ref v) = self.default_symbol_visibility {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let Some(ref v) = self.field_presence {
            ::buffa::types::put_int32_field(1u32, v.to_i32(), buf);
        }
        if let Some(ref v) = self.enum_type {
            ::buffa::types::put_int32_field(2u32, v.to_i32(), buf);
        }
        if let Some(ref v) = self.repeated_field_encoding {
            ::buffa::types::put_int32_field(3u32, v.to_i32(), buf);
        }
        if let Some(ref v) = self.utf8_validation {
            ::buffa::types::put_int32_field(4u32, v.to_i32(), buf);
        }
        if let Some(ref v) = self.message_encoding {
            ::buffa::types::put_int32_field(5u32, v.to_i32(), buf);
        }
        if let Some(ref v) = self.json_format {
            ::buffa::types::put_int32_field(6u32, v.to_i32(), buf);
        }
        if let Some(ref v) = self.enforce_naming_style {
            ::buffa::types::put_int32_field(7u32, v.to_i32(), buf);
        }
        if let Some(ref v) = self.default_symbol_visibility {
            ::buffa::types::put_int32_field(8u32, v.to_i32(), buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.field_presence = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 1u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.enum_type = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 2u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.repeated_field_encoding = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 3u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.utf8_validation = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 4u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.message_encoding = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 5u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.json_format = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 6u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.enforce_naming_style = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 7u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.default_symbol_visibility = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 8u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.field_presence = ::core::option::Option::None;
        self.enum_type = ::core::option::Option::None;
        self.repeated_field_encoding = ::core::option::Option::None;
        self.utf8_validation = ::core::option::Option::None;
        self.message_encoding = ::core::option::Option::None;
        self.json_format = ::core::option::Option::None;
        self.enforce_naming_style = ::core::option::Option::None;
        self.default_symbol_visibility = ::core::option::Option::None;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for FeatureSet {
    const PROTO_FQN: &'static str = "google.protobuf.FeatureSet";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for FeatureSet {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref __v) = self.field_presence {
            enc.write_field_name("field_presence")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        if let ::core::option::Option::Some(ref __v) = self.enum_type {
            enc.write_field_name("enum_type")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        if let ::core::option::Option::Some(ref __v) = self.repeated_field_encoding {
            enc.write_field_name("repeated_field_encoding")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        if let ::core::option::Option::Some(ref __v) = self.utf8_validation {
            enc.write_field_name("utf8_validation")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        if let ::core::option::Option::Some(ref __v) = self.message_encoding {
            enc.write_field_name("message_encoding")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        if let ::core::option::Option::Some(ref __v) = self.json_format {
            enc.write_field_name("json_format")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        if let ::core::option::Option::Some(ref __v) = self.enforce_naming_style {
            enc.write_field_name("enforce_naming_style")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        if let ::core::option::Option::Some(ref __v) = self.default_symbol_visibility {
            enc.write_field_name("default_symbol_visibility")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        enc.write_extension_fields(
            "google.protobuf.FeatureSet",
            &self.__buffa_unknown_fields,
        )?;
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "field_presence" => {
                    self.field_presence = ::core::option::Option::Some(
                        dec.read_closed_enum_by_name::<feature_set::FieldPresence>()?,
                    );
                }
                "enum_type" => {
                    self.enum_type = ::core::option::Option::Some(
                        dec.read_closed_enum_by_name::<feature_set::EnumType>()?,
                    );
                }
                "repeated_field_encoding" => {
                    self.repeated_field_encoding = ::core::option::Option::Some(
                        dec
                            .read_closed_enum_by_name::<
                                feature_set::RepeatedFieldEncoding,
                            >()?,
                    );
                }
                "utf8_validation" => {
                    self.utf8_validation = ::core::option::Option::Some(
                        dec.read_closed_enum_by_name::<feature_set::Utf8Validation>()?,
                    );
                }
                "message_encoding" => {
                    self.message_encoding = ::core::option::Option::Some(
                        dec.read_closed_enum_by_name::<feature_set::MessageEncoding>()?,
                    );
                }
                "json_format" => {
                    self.json_format = ::core::option::Option::Some(
                        dec.read_closed_enum_by_name::<feature_set::JsonFormat>()?,
                    );
                }
                "enforce_naming_style" => {
                    self.enforce_naming_style = ::core::option::Option::Some(
                        dec
                            .read_closed_enum_by_name::<
                                feature_set::EnforceNamingStyle,
                            >()?,
                    );
                }
                "default_symbol_visibility" => {
                    self.default_symbol_visibility = ::core::option::Option::Some(
                        dec
                            .read_closed_enum_by_name::<
                                feature_set::visibility_feature::DefaultSymbolVisibility,
                            >()?,
                    );
                }
                __name if __name.starts_with('[') => {
                    for __r in dec.read_extension(__name, "google.protobuf.FeatureSet")?
                    {
                        self.__buffa_unknown_fields.push(__r);
                    }
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl<'de> serde::Deserialize<'de> for FeatureSet {
    fn deserialize<D: serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl<'de> serde::de::Visitor<'de> for _V {
            type Value = FeatureSet;
            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                f.write_str("struct FeatureSet")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<FeatureSet, A::Error> {
                let mut __f_field_presence: ::core::option::Option<
                    ::core::option::Option<feature_set::FieldPresence>,
                > = None;
                let mut __f_enum_type: ::core::option::Option<
                    ::core::option::Option<feature_set::EnumType>,
                > = None;
                let mut __f_repeated_field_encoding: ::core::option::Option<
                    ::core::option::Option<feature_set::RepeatedFieldEncoding>,
                > = None;
                let mut __f_utf8_validation: ::core::option::Option<
                    ::core::option::Option<feature_set::Utf8Validation>,
                > = None;
                let mut __f_message_encoding: ::core::option::Option<
                    ::core::option::Option<feature_set::MessageEncoding>,
                > = None;
                let mut __f_json_format: ::core::option::Option<
                    ::core::option::Option<feature_set::JsonFormat>,
                > = None;
                let mut __f_enforce_naming_style: ::core::option::Option<
                    ::core::option::Option<feature_set::EnforceNamingStyle>,
                > = None;
                let mut __f_default_symbol_visibility: ::core::option::Option<
                    ::core::option::Option<
                        feature_set::visibility_feature::DefaultSymbolVisibility,
                    >,
                > = None;
                let mut __ext_records: ::buffa::alloc::vec::Vec<::buffa::UnknownField> = ::buffa::alloc::vec::Vec::new();
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "fieldPresence" | "field_presence" => {
                            __f_field_presence = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::core::option::Option<
                                        feature_set::FieldPresence,
                                    >;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::core::option::Option<feature_set::FieldPresence>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::opt_closed_enum::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "enumType" | "enum_type" => {
                            __f_enum_type = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::core::option::Option<feature_set::EnumType>;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::core::option::Option<feature_set::EnumType>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::opt_closed_enum::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "repeatedFieldEncoding" | "repeated_field_encoding" => {
                            __f_repeated_field_encoding = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::core::option::Option<
                                        feature_set::RepeatedFieldEncoding,
                                    >;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::core::option::Option<feature_set::RepeatedFieldEncoding>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::opt_closed_enum::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "utf8Validation" | "utf8_validation" => {
                            __f_utf8_validation = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::core::option::Option<
                                        feature_set::Utf8Validation,
                                    >;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::core::option::Option<feature_set::Utf8Validation>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::opt_closed_enum::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "messageEncoding" | "message_encoding" => {
                            __f_message_encoding = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::core::option::Option<
                                        feature_set::MessageEncoding,
                                    >;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::core::option::Option<feature_set::MessageEncoding>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::opt_closed_enum::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "jsonFormat" | "json_format" => {
                            __f_json_format = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::core::option::Option<
                                        feature_set::JsonFormat,
                                    >;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::core::option::Option<feature_set::JsonFormat>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::opt_closed_enum::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "enforceNamingStyle" | "enforce_naming_style" => {
                            __f_enforce_naming_style = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::core::option::Option<
                                        feature_set::EnforceNamingStyle,
                                    >;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::core::option::Option<feature_set::EnforceNamingStyle>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::opt_closed_enum::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "defaultSymbolVisibility" | "default_symbol_visibility" => {
                            __f_default_symbol_visibility = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::core::option::Option<
                                        feature_set::visibility_feature::DefaultSymbolVisibility,
                                    >;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::core::option::Option<
                                            feature_set::visibility_feature::DefaultSymbolVisibility,
                                        >,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::opt_closed_enum::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        __k if __k.starts_with('[') => {
                            let __v: ::buffa::serde_json::Value = map.next_value()?;
                            match ::buffa::extension_registry::deserialize_extension_key(
                                "google.protobuf.FeatureSet",
                                __k,
                                __v,
                            ) {
                                ::core::option::Option::Some(
                                    ::core::result::Result::Ok(__recs),
                                ) => {
                                    for __rec in __recs {
                                        __ext_records.push(__rec);
                                    }
                                }
                                ::core::option::Option::Some(
                                    ::core::result::Result::Err(__e),
                                ) => {
                                    return ::core::result::Result::Err(
                                        <A::Error as ::serde::de::Error>::custom(__e),
                                    );
                                }
                                ::core::option::Option::None => {}
                            }
                        }
                        _ => {
                            map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                let mut __r = <FeatureSet as ::core::default::Default>::default();
                if let ::core::option::Option::Some(v) = __f_field_presence {
                    __r.field_presence = v;
                }
                if let ::core::option::Option::Some(v) = __f_enum_type {
                    __r.enum_type = v;
                }
                if let ::core::option::Option::Some(v) = __f_repeated_field_encoding {
                    __r.repeated_field_encoding = v;
                }
                if let ::core::option::Option::Some(v) = __f_utf8_validation {
                    __r.utf8_validation = v;
                }
                if let ::core::option::Option::Some(v) = __f_message_encoding {
                    __r.message_encoding = v;
                }
                if let ::core::option::Option::Some(v) = __f_json_format {
                    __r.json_format = v;
                }
                if let ::core::option::Option::Some(v) = __f_enforce_naming_style {
                    __r.enforce_naming_style = v;
                }
                if let ::core::option::Option::Some(v) = __f_default_symbol_visibility {
                    __r.default_symbol_visibility = v;
                }
                for __rec in __ext_records {
                    __r.__buffa_unknown_fields.push(__rec);
                }
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for FeatureSet {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
#[derive(Clone, Debug, Default, PartialEq)]
#[repr(transparent)]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct __FeatureSetExtJson(pub ::buffa::UnknownFields);
impl ::core::ops::Deref for __FeatureSetExtJson {
    type Target = ::buffa::UnknownFields;
    fn deref(&self) -> &::buffa::UnknownFields {
        &self.0
    }
}
impl ::core::ops::DerefMut for __FeatureSetExtJson {
    fn deref_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.0
    }
}
impl ::core::convert::From<::buffa::UnknownFields> for __FeatureSetExtJson {
    fn from(u: ::buffa::UnknownFields) -> Self {
        Self(u)
    }
}
#[cfg(feature = "json")]
impl ::serde::Serialize for __FeatureSetExtJson {
    fn serialize<S: ::serde::Serializer>(
        &self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::buffa::extension_registry::serialize_extensions(
            "google.protobuf.FeatureSet",
            &self.0,
            s,
        )
    }
}
#[cfg(feature = "json")]
impl<'de> ::serde::Deserialize<'de> for __FeatureSetExtJson {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        ::buffa::extension_registry::deserialize_extensions(
                "google.protobuf.FeatureSet",
                d,
            )
            .map(Self)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __FEATURE_SET_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.FeatureSet",
    to_json: ::buffa::type_registry::any_to_json::<FeatureSet>,
    from_json: ::buffa::type_registry::any_from_json::<FeatureSet>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __FEATURE_SET_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.FeatureSet",
    text_encode: ::buffa::type_registry::any_encode_text::<FeatureSet>,
    text_merge: ::buffa::type_registry::any_merge_text::<FeatureSet>,
};
pub mod feature_set {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    #[repr(i32)]
    pub enum FieldPresence {
        FIELD_PRESENCE_UNKNOWN = 0i32,
        EXPLICIT = 1i32,
        IMPLICIT = 2i32,
        LEGACY_REQUIRED = 3i32,
    }
    impl FieldPresence {
        ///Idiomatic alias for [`Self::FIELD_PRESENCE_UNKNOWN`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const FieldPresenceUnknown: Self = Self::FIELD_PRESENCE_UNKNOWN;
        ///Idiomatic alias for [`Self::EXPLICIT`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Explicit: Self = Self::EXPLICIT;
        ///Idiomatic alias for [`Self::IMPLICIT`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Implicit: Self = Self::IMPLICIT;
        ///Idiomatic alias for [`Self::LEGACY_REQUIRED`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const LegacyRequired: Self = Self::LEGACY_REQUIRED;
    }
    impl ::core::default::Default for FieldPresence {
        fn default() -> Self {
            Self::FIELD_PRESENCE_UNKNOWN
        }
    }
    #[cfg(feature = "json")]
    const _: () = {
        impl ::serde::Serialize for FieldPresence {
            fn serialize<S: ::serde::Serializer>(
                &self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                s.serialize_str(::buffa::Enumeration::proto_name(self))
            }
        }
        impl<'de> ::serde::Deserialize<'de> for FieldPresence {
            fn deserialize<D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                struct _V;
                impl ::serde::de::Visitor<'_> for _V {
                    type Value = FieldPresence;
                    fn expecting(
                        &self,
                        f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        f.write_str(
                            concat!(
                                "a string, integer, or null for ", stringify!(FieldPresence)
                            ),
                        )
                    }
                    fn visit_str<E: ::serde::de::Error>(
                        self,
                        v: &str,
                    ) -> ::core::result::Result<FieldPresence, E> {
                        <FieldPresence as ::buffa::Enumeration>::from_proto_name(v)
                            .ok_or_else(|| {
                                ::serde::de::Error::unknown_variant(v, &[])
                            })
                    }
                    fn visit_i64<E: ::serde::de::Error>(
                        self,
                        v: i64,
                    ) -> ::core::result::Result<FieldPresence, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <FieldPresence as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_u64<E: ::serde::de::Error>(
                        self,
                        v: u64,
                    ) -> ::core::result::Result<FieldPresence, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <FieldPresence as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_unit<E: ::serde::de::Error>(
                        self,
                    ) -> ::core::result::Result<FieldPresence, E> {
                        ::core::result::Result::Ok(::core::default::Default::default())
                    }
                }
                d.deserialize_any(_V)
            }
        }
        impl ::buffa::json_helpers::ProtoElemJson for FieldPresence {
            fn serialize_proto_json<S: ::serde::Serializer>(
                v: &Self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                ::serde::Serialize::serialize(v, s)
            }
            fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                <Self as ::serde::Deserialize>::deserialize(d)
            }
        }
    };
    impl ::buffa::Enumeration for FieldPresence {
        fn from_i32(value: i32) -> ::core::option::Option<Self> {
            match value {
                0i32 => ::core::option::Option::Some(Self::FIELD_PRESENCE_UNKNOWN),
                1i32 => ::core::option::Option::Some(Self::EXPLICIT),
                2i32 => ::core::option::Option::Some(Self::IMPLICIT),
                3i32 => ::core::option::Option::Some(Self::LEGACY_REQUIRED),
                _ => ::core::option::Option::None,
            }
        }
        fn to_i32(&self) -> i32 {
            *self as i32
        }
        fn proto_name(&self) -> &'static str {
            match self {
                Self::FIELD_PRESENCE_UNKNOWN => "FIELD_PRESENCE_UNKNOWN",
                Self::EXPLICIT => "EXPLICIT",
                Self::IMPLICIT => "IMPLICIT",
                Self::LEGACY_REQUIRED => "LEGACY_REQUIRED",
            }
        }
        fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
            match name {
                "FIELD_PRESENCE_UNKNOWN" => {
                    ::core::option::Option::Some(Self::FIELD_PRESENCE_UNKNOWN)
                }
                "EXPLICIT" => ::core::option::Option::Some(Self::EXPLICIT),
                "IMPLICIT" => ::core::option::Option::Some(Self::IMPLICIT),
                "LEGACY_REQUIRED" => ::core::option::Option::Some(Self::LEGACY_REQUIRED),
                _ => ::core::option::Option::None,
            }
        }
        fn values() -> &'static [Self] {
            &[
                Self::FIELD_PRESENCE_UNKNOWN,
                Self::EXPLICIT,
                Self::IMPLICIT,
                Self::LEGACY_REQUIRED,
            ]
        }
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    #[repr(i32)]
    pub enum EnumType {
        ENUM_TYPE_UNKNOWN = 0i32,
        OPEN = 1i32,
        CLOSED = 2i32,
    }
    impl EnumType {
        ///Idiomatic alias for [`Self::ENUM_TYPE_UNKNOWN`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const EnumTypeUnknown: Self = Self::ENUM_TYPE_UNKNOWN;
        ///Idiomatic alias for [`Self::OPEN`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Open: Self = Self::OPEN;
        ///Idiomatic alias for [`Self::CLOSED`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Closed: Self = Self::CLOSED;
    }
    impl ::core::default::Default for EnumType {
        fn default() -> Self {
            Self::ENUM_TYPE_UNKNOWN
        }
    }
    #[cfg(feature = "json")]
    const _: () = {
        impl ::serde::Serialize for EnumType {
            fn serialize<S: ::serde::Serializer>(
                &self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                s.serialize_str(::buffa::Enumeration::proto_name(self))
            }
        }
        impl<'de> ::serde::Deserialize<'de> for EnumType {
            fn deserialize<D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                struct _V;
                impl ::serde::de::Visitor<'_> for _V {
                    type Value = EnumType;
                    fn expecting(
                        &self,
                        f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        f.write_str(
                            concat!(
                                "a string, integer, or null for ", stringify!(EnumType)
                            ),
                        )
                    }
                    fn visit_str<E: ::serde::de::Error>(
                        self,
                        v: &str,
                    ) -> ::core::result::Result<EnumType, E> {
                        <EnumType as ::buffa::Enumeration>::from_proto_name(v)
                            .ok_or_else(|| {
                                ::serde::de::Error::unknown_variant(v, &[])
                            })
                    }
                    fn visit_i64<E: ::serde::de::Error>(
                        self,
                        v: i64,
                    ) -> ::core::result::Result<EnumType, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <EnumType as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_u64<E: ::serde::de::Error>(
                        self,
                        v: u64,
                    ) -> ::core::result::Result<EnumType, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <EnumType as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_unit<E: ::serde::de::Error>(
                        self,
                    ) -> ::core::result::Result<EnumType, E> {
                        ::core::result::Result::Ok(::core::default::Default::default())
                    }
                }
                d.deserialize_any(_V)
            }
        }
        impl ::buffa::json_helpers::ProtoElemJson for EnumType {
            fn serialize_proto_json<S: ::serde::Serializer>(
                v: &Self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                ::serde::Serialize::serialize(v, s)
            }
            fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                <Self as ::serde::Deserialize>::deserialize(d)
            }
        }
    };
    impl ::buffa::Enumeration for EnumType {
        fn from_i32(value: i32) -> ::core::option::Option<Self> {
            match value {
                0i32 => ::core::option::Option::Some(Self::ENUM_TYPE_UNKNOWN),
                1i32 => ::core::option::Option::Some(Self::OPEN),
                2i32 => ::core::option::Option::Some(Self::CLOSED),
                _ => ::core::option::Option::None,
            }
        }
        fn to_i32(&self) -> i32 {
            *self as i32
        }
        fn proto_name(&self) -> &'static str {
            match self {
                Self::ENUM_TYPE_UNKNOWN => "ENUM_TYPE_UNKNOWN",
                Self::OPEN => "OPEN",
                Self::CLOSED => "CLOSED",
            }
        }
        fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
            match name {
                "ENUM_TYPE_UNKNOWN" => {
                    ::core::option::Option::Some(Self::ENUM_TYPE_UNKNOWN)
                }
                "OPEN" => ::core::option::Option::Some(Self::OPEN),
                "CLOSED" => ::core::option::Option::Some(Self::CLOSED),
                _ => ::core::option::Option::None,
            }
        }
        fn values() -> &'static [Self] {
            &[Self::ENUM_TYPE_UNKNOWN, Self::OPEN, Self::CLOSED]
        }
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    #[repr(i32)]
    pub enum RepeatedFieldEncoding {
        REPEATED_FIELD_ENCODING_UNKNOWN = 0i32,
        PACKED = 1i32,
        EXPANDED = 2i32,
    }
    impl RepeatedFieldEncoding {
        ///Idiomatic alias for [`Self::REPEATED_FIELD_ENCODING_UNKNOWN`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const RepeatedFieldEncodingUnknown: Self = Self::REPEATED_FIELD_ENCODING_UNKNOWN;
        ///Idiomatic alias for [`Self::PACKED`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Packed: Self = Self::PACKED;
        ///Idiomatic alias for [`Self::EXPANDED`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Expanded: Self = Self::EXPANDED;
    }
    impl ::core::default::Default for RepeatedFieldEncoding {
        fn default() -> Self {
            Self::REPEATED_FIELD_ENCODING_UNKNOWN
        }
    }
    #[cfg(feature = "json")]
    const _: () = {
        impl ::serde::Serialize for RepeatedFieldEncoding {
            fn serialize<S: ::serde::Serializer>(
                &self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                s.serialize_str(::buffa::Enumeration::proto_name(self))
            }
        }
        impl<'de> ::serde::Deserialize<'de> for RepeatedFieldEncoding {
            fn deserialize<D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                struct _V;
                impl ::serde::de::Visitor<'_> for _V {
                    type Value = RepeatedFieldEncoding;
                    fn expecting(
                        &self,
                        f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        f.write_str(
                            concat!(
                                "a string, integer, or null for ",
                                stringify!(RepeatedFieldEncoding)
                            ),
                        )
                    }
                    fn visit_str<E: ::serde::de::Error>(
                        self,
                        v: &str,
                    ) -> ::core::result::Result<RepeatedFieldEncoding, E> {
                        <RepeatedFieldEncoding as ::buffa::Enumeration>::from_proto_name(
                                v,
                            )
                            .ok_or_else(|| {
                                ::serde::de::Error::unknown_variant(v, &[])
                            })
                    }
                    fn visit_i64<E: ::serde::de::Error>(
                        self,
                        v: i64,
                    ) -> ::core::result::Result<RepeatedFieldEncoding, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <RepeatedFieldEncoding as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_u64<E: ::serde::de::Error>(
                        self,
                        v: u64,
                    ) -> ::core::result::Result<RepeatedFieldEncoding, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <RepeatedFieldEncoding as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_unit<E: ::serde::de::Error>(
                        self,
                    ) -> ::core::result::Result<RepeatedFieldEncoding, E> {
                        ::core::result::Result::Ok(::core::default::Default::default())
                    }
                }
                d.deserialize_any(_V)
            }
        }
        impl ::buffa::json_helpers::ProtoElemJson for RepeatedFieldEncoding {
            fn serialize_proto_json<S: ::serde::Serializer>(
                v: &Self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                ::serde::Serialize::serialize(v, s)
            }
            fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                <Self as ::serde::Deserialize>::deserialize(d)
            }
        }
    };
    impl ::buffa::Enumeration for RepeatedFieldEncoding {
        fn from_i32(value: i32) -> ::core::option::Option<Self> {
            match value {
                0i32 => {
                    ::core::option::Option::Some(Self::REPEATED_FIELD_ENCODING_UNKNOWN)
                }
                1i32 => ::core::option::Option::Some(Self::PACKED),
                2i32 => ::core::option::Option::Some(Self::EXPANDED),
                _ => ::core::option::Option::None,
            }
        }
        fn to_i32(&self) -> i32 {
            *self as i32
        }
        fn proto_name(&self) -> &'static str {
            match self {
                Self::REPEATED_FIELD_ENCODING_UNKNOWN => {
                    "REPEATED_FIELD_ENCODING_UNKNOWN"
                }
                Self::PACKED => "PACKED",
                Self::EXPANDED => "EXPANDED",
            }
        }
        fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
            match name {
                "REPEATED_FIELD_ENCODING_UNKNOWN" => {
                    ::core::option::Option::Some(Self::REPEATED_FIELD_ENCODING_UNKNOWN)
                }
                "PACKED" => ::core::option::Option::Some(Self::PACKED),
                "EXPANDED" => ::core::option::Option::Some(Self::EXPANDED),
                _ => ::core::option::Option::None,
            }
        }
        fn values() -> &'static [Self] {
            &[Self::REPEATED_FIELD_ENCODING_UNKNOWN, Self::PACKED, Self::EXPANDED]
        }
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    #[repr(i32)]
    pub enum Utf8Validation {
        UTF8_VALIDATION_UNKNOWN = 0i32,
        VERIFY = 2i32,
        NONE = 3i32,
    }
    impl Utf8Validation {
        ///Idiomatic alias for [`Self::UTF8_VALIDATION_UNKNOWN`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Utf8ValidationUnknown: Self = Self::UTF8_VALIDATION_UNKNOWN;
        ///Idiomatic alias for [`Self::VERIFY`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Verify: Self = Self::VERIFY;
        ///Idiomatic alias for [`Self::NONE`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const None: Self = Self::NONE;
    }
    impl ::core::default::Default for Utf8Validation {
        fn default() -> Self {
            Self::UTF8_VALIDATION_UNKNOWN
        }
    }
    #[cfg(feature = "json")]
    const _: () = {
        impl ::serde::Serialize for Utf8Validation {
            fn serialize<S: ::serde::Serializer>(
                &self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                s.serialize_str(::buffa::Enumeration::proto_name(self))
            }
        }
        impl<'de> ::serde::Deserialize<'de> for Utf8Validation {
            fn deserialize<D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                struct _V;
                impl ::serde::de::Visitor<'_> for _V {
                    type Value = Utf8Validation;
                    fn expecting(
                        &self,
                        f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        f.write_str(
                            concat!(
                                "a string, integer, or null for ",
                                stringify!(Utf8Validation)
                            ),
                        )
                    }
                    fn visit_str<E: ::serde::de::Error>(
                        self,
                        v: &str,
                    ) -> ::core::result::Result<Utf8Validation, E> {
                        <Utf8Validation as ::buffa::Enumeration>::from_proto_name(v)
                            .ok_or_else(|| {
                                ::serde::de::Error::unknown_variant(v, &[])
                            })
                    }
                    fn visit_i64<E: ::serde::de::Error>(
                        self,
                        v: i64,
                    ) -> ::core::result::Result<Utf8Validation, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <Utf8Validation as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_u64<E: ::serde::de::Error>(
                        self,
                        v: u64,
                    ) -> ::core::result::Result<Utf8Validation, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <Utf8Validation as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_unit<E: ::serde::de::Error>(
                        self,
                    ) -> ::core::result::Result<Utf8Validation, E> {
                        ::core::result::Result::Ok(::core::default::Default::default())
                    }
                }
                d.deserialize_any(_V)
            }
        }
        impl ::buffa::json_helpers::ProtoElemJson for Utf8Validation {
            fn serialize_proto_json<S: ::serde::Serializer>(
                v: &Self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                ::serde::Serialize::serialize(v, s)
            }
            fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                <Self as ::serde::Deserialize>::deserialize(d)
            }
        }
    };
    impl ::buffa::Enumeration for Utf8Validation {
        fn from_i32(value: i32) -> ::core::option::Option<Self> {
            match value {
                0i32 => ::core::option::Option::Some(Self::UTF8_VALIDATION_UNKNOWN),
                2i32 => ::core::option::Option::Some(Self::VERIFY),
                3i32 => ::core::option::Option::Some(Self::NONE),
                _ => ::core::option::Option::None,
            }
        }
        fn to_i32(&self) -> i32 {
            *self as i32
        }
        fn proto_name(&self) -> &'static str {
            match self {
                Self::UTF8_VALIDATION_UNKNOWN => "UTF8_VALIDATION_UNKNOWN",
                Self::VERIFY => "VERIFY",
                Self::NONE => "NONE",
            }
        }
        fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
            match name {
                "UTF8_VALIDATION_UNKNOWN" => {
                    ::core::option::Option::Some(Self::UTF8_VALIDATION_UNKNOWN)
                }
                "VERIFY" => ::core::option::Option::Some(Self::VERIFY),
                "NONE" => ::core::option::Option::Some(Self::NONE),
                _ => ::core::option::Option::None,
            }
        }
        fn values() -> &'static [Self] {
            &[Self::UTF8_VALIDATION_UNKNOWN, Self::VERIFY, Self::NONE]
        }
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    #[repr(i32)]
    pub enum MessageEncoding {
        MESSAGE_ENCODING_UNKNOWN = 0i32,
        LENGTH_PREFIXED = 1i32,
        DELIMITED = 2i32,
    }
    impl MessageEncoding {
        ///Idiomatic alias for [`Self::MESSAGE_ENCODING_UNKNOWN`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const MessageEncodingUnknown: Self = Self::MESSAGE_ENCODING_UNKNOWN;
        ///Idiomatic alias for [`Self::LENGTH_PREFIXED`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const LengthPrefixed: Self = Self::LENGTH_PREFIXED;
        ///Idiomatic alias for [`Self::DELIMITED`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Delimited: Self = Self::DELIMITED;
    }
    impl ::core::default::Default for MessageEncoding {
        fn default() -> Self {
            Self::MESSAGE_ENCODING_UNKNOWN
        }
    }
    #[cfg(feature = "json")]
    const _: () = {
        impl ::serde::Serialize for MessageEncoding {
            fn serialize<S: ::serde::Serializer>(
                &self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                s.serialize_str(::buffa::Enumeration::proto_name(self))
            }
        }
        impl<'de> ::serde::Deserialize<'de> for MessageEncoding {
            fn deserialize<D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                struct _V;
                impl ::serde::de::Visitor<'_> for _V {
                    type Value = MessageEncoding;
                    fn expecting(
                        &self,
                        f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        f.write_str(
                            concat!(
                                "a string, integer, or null for ",
                                stringify!(MessageEncoding)
                            ),
                        )
                    }
                    fn visit_str<E: ::serde::de::Error>(
                        self,
                        v: &str,
                    ) -> ::core::result::Result<MessageEncoding, E> {
                        <MessageEncoding as ::buffa::Enumeration>::from_proto_name(v)
                            .ok_or_else(|| {
                                ::serde::de::Error::unknown_variant(v, &[])
                            })
                    }
                    fn visit_i64<E: ::serde::de::Error>(
                        self,
                        v: i64,
                    ) -> ::core::result::Result<MessageEncoding, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <MessageEncoding as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_u64<E: ::serde::de::Error>(
                        self,
                        v: u64,
                    ) -> ::core::result::Result<MessageEncoding, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <MessageEncoding as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_unit<E: ::serde::de::Error>(
                        self,
                    ) -> ::core::result::Result<MessageEncoding, E> {
                        ::core::result::Result::Ok(::core::default::Default::default())
                    }
                }
                d.deserialize_any(_V)
            }
        }
        impl ::buffa::json_helpers::ProtoElemJson for MessageEncoding {
            fn serialize_proto_json<S: ::serde::Serializer>(
                v: &Self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                ::serde::Serialize::serialize(v, s)
            }
            fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                <Self as ::serde::Deserialize>::deserialize(d)
            }
        }
    };
    impl ::buffa::Enumeration for MessageEncoding {
        fn from_i32(value: i32) -> ::core::option::Option<Self> {
            match value {
                0i32 => ::core::option::Option::Some(Self::MESSAGE_ENCODING_UNKNOWN),
                1i32 => ::core::option::Option::Some(Self::LENGTH_PREFIXED),
                2i32 => ::core::option::Option::Some(Self::DELIMITED),
                _ => ::core::option::Option::None,
            }
        }
        fn to_i32(&self) -> i32 {
            *self as i32
        }
        fn proto_name(&self) -> &'static str {
            match self {
                Self::MESSAGE_ENCODING_UNKNOWN => "MESSAGE_ENCODING_UNKNOWN",
                Self::LENGTH_PREFIXED => "LENGTH_PREFIXED",
                Self::DELIMITED => "DELIMITED",
            }
        }
        fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
            match name {
                "MESSAGE_ENCODING_UNKNOWN" => {
                    ::core::option::Option::Some(Self::MESSAGE_ENCODING_UNKNOWN)
                }
                "LENGTH_PREFIXED" => ::core::option::Option::Some(Self::LENGTH_PREFIXED),
                "DELIMITED" => ::core::option::Option::Some(Self::DELIMITED),
                _ => ::core::option::Option::None,
            }
        }
        fn values() -> &'static [Self] {
            &[Self::MESSAGE_ENCODING_UNKNOWN, Self::LENGTH_PREFIXED, Self::DELIMITED]
        }
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    #[repr(i32)]
    pub enum JsonFormat {
        JSON_FORMAT_UNKNOWN = 0i32,
        ALLOW = 1i32,
        LEGACY_BEST_EFFORT = 2i32,
    }
    impl JsonFormat {
        ///Idiomatic alias for [`Self::JSON_FORMAT_UNKNOWN`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const JsonFormatUnknown: Self = Self::JSON_FORMAT_UNKNOWN;
        ///Idiomatic alias for [`Self::ALLOW`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Allow: Self = Self::ALLOW;
        ///Idiomatic alias for [`Self::LEGACY_BEST_EFFORT`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const LegacyBestEffort: Self = Self::LEGACY_BEST_EFFORT;
    }
    impl ::core::default::Default for JsonFormat {
        fn default() -> Self {
            Self::JSON_FORMAT_UNKNOWN
        }
    }
    #[cfg(feature = "json")]
    const _: () = {
        impl ::serde::Serialize for JsonFormat {
            fn serialize<S: ::serde::Serializer>(
                &self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                s.serialize_str(::buffa::Enumeration::proto_name(self))
            }
        }
        impl<'de> ::serde::Deserialize<'de> for JsonFormat {
            fn deserialize<D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                struct _V;
                impl ::serde::de::Visitor<'_> for _V {
                    type Value = JsonFormat;
                    fn expecting(
                        &self,
                        f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        f.write_str(
                            concat!(
                                "a string, integer, or null for ", stringify!(JsonFormat)
                            ),
                        )
                    }
                    fn visit_str<E: ::serde::de::Error>(
                        self,
                        v: &str,
                    ) -> ::core::result::Result<JsonFormat, E> {
                        <JsonFormat as ::buffa::Enumeration>::from_proto_name(v)
                            .ok_or_else(|| {
                                ::serde::de::Error::unknown_variant(v, &[])
                            })
                    }
                    fn visit_i64<E: ::serde::de::Error>(
                        self,
                        v: i64,
                    ) -> ::core::result::Result<JsonFormat, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <JsonFormat as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_u64<E: ::serde::de::Error>(
                        self,
                        v: u64,
                    ) -> ::core::result::Result<JsonFormat, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <JsonFormat as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_unit<E: ::serde::de::Error>(
                        self,
                    ) -> ::core::result::Result<JsonFormat, E> {
                        ::core::result::Result::Ok(::core::default::Default::default())
                    }
                }
                d.deserialize_any(_V)
            }
        }
        impl ::buffa::json_helpers::ProtoElemJson for JsonFormat {
            fn serialize_proto_json<S: ::serde::Serializer>(
                v: &Self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                ::serde::Serialize::serialize(v, s)
            }
            fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                <Self as ::serde::Deserialize>::deserialize(d)
            }
        }
    };
    impl ::buffa::Enumeration for JsonFormat {
        fn from_i32(value: i32) -> ::core::option::Option<Self> {
            match value {
                0i32 => ::core::option::Option::Some(Self::JSON_FORMAT_UNKNOWN),
                1i32 => ::core::option::Option::Some(Self::ALLOW),
                2i32 => ::core::option::Option::Some(Self::LEGACY_BEST_EFFORT),
                _ => ::core::option::Option::None,
            }
        }
        fn to_i32(&self) -> i32 {
            *self as i32
        }
        fn proto_name(&self) -> &'static str {
            match self {
                Self::JSON_FORMAT_UNKNOWN => "JSON_FORMAT_UNKNOWN",
                Self::ALLOW => "ALLOW",
                Self::LEGACY_BEST_EFFORT => "LEGACY_BEST_EFFORT",
            }
        }
        fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
            match name {
                "JSON_FORMAT_UNKNOWN" => {
                    ::core::option::Option::Some(Self::JSON_FORMAT_UNKNOWN)
                }
                "ALLOW" => ::core::option::Option::Some(Self::ALLOW),
                "LEGACY_BEST_EFFORT" => {
                    ::core::option::Option::Some(Self::LEGACY_BEST_EFFORT)
                }
                _ => ::core::option::Option::None,
            }
        }
        fn values() -> &'static [Self] {
            &[Self::JSON_FORMAT_UNKNOWN, Self::ALLOW, Self::LEGACY_BEST_EFFORT]
        }
    }
    #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    #[repr(i32)]
    pub enum EnforceNamingStyle {
        ENFORCE_NAMING_STYLE_UNKNOWN = 0i32,
        STYLE2024 = 1i32,
        STYLE_LEGACY = 2i32,
    }
    impl EnforceNamingStyle {
        ///Idiomatic alias for [`Self::ENFORCE_NAMING_STYLE_UNKNOWN`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const EnforceNamingStyleUnknown: Self = Self::ENFORCE_NAMING_STYLE_UNKNOWN;
        ///Idiomatic alias for [`Self::STYLE2024`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const Style2024: Self = Self::STYLE2024;
        ///Idiomatic alias for [`Self::STYLE_LEGACY`]; `Debug` prints the variant name.
        #[allow(non_upper_case_globals)]
        pub const StyleLegacy: Self = Self::STYLE_LEGACY;
    }
    impl ::core::default::Default for EnforceNamingStyle {
        fn default() -> Self {
            Self::ENFORCE_NAMING_STYLE_UNKNOWN
        }
    }
    #[cfg(feature = "json")]
    const _: () = {
        impl ::serde::Serialize for EnforceNamingStyle {
            fn serialize<S: ::serde::Serializer>(
                &self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                s.serialize_str(::buffa::Enumeration::proto_name(self))
            }
        }
        impl<'de> ::serde::Deserialize<'de> for EnforceNamingStyle {
            fn deserialize<D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                struct _V;
                impl ::serde::de::Visitor<'_> for _V {
                    type Value = EnforceNamingStyle;
                    fn expecting(
                        &self,
                        f: &mut ::core::fmt::Formatter<'_>,
                    ) -> ::core::fmt::Result {
                        f.write_str(
                            concat!(
                                "a string, integer, or null for ",
                                stringify!(EnforceNamingStyle)
                            ),
                        )
                    }
                    fn visit_str<E: ::serde::de::Error>(
                        self,
                        v: &str,
                    ) -> ::core::result::Result<EnforceNamingStyle, E> {
                        <EnforceNamingStyle as ::buffa::Enumeration>::from_proto_name(v)
                            .ok_or_else(|| {
                                ::serde::de::Error::unknown_variant(v, &[])
                            })
                    }
                    fn visit_i64<E: ::serde::de::Error>(
                        self,
                        v: i64,
                    ) -> ::core::result::Result<EnforceNamingStyle, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <EnforceNamingStyle as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_u64<E: ::serde::de::Error>(
                        self,
                        v: u64,
                    ) -> ::core::result::Result<EnforceNamingStyle, E> {
                        let v32 = i32::try_from(v)
                            .map_err(|_| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                )
                            })?;
                        <EnforceNamingStyle as ::buffa::Enumeration>::from_i32(v32)
                            .ok_or_else(|| {
                                ::serde::de::Error::custom(
                                    ::buffa::alloc::format!("unknown enum value {v32}"),
                                )
                            })
                    }
                    fn visit_unit<E: ::serde::de::Error>(
                        self,
                    ) -> ::core::result::Result<EnforceNamingStyle, E> {
                        ::core::result::Result::Ok(::core::default::Default::default())
                    }
                }
                d.deserialize_any(_V)
            }
        }
        impl ::buffa::json_helpers::ProtoElemJson for EnforceNamingStyle {
            fn serialize_proto_json<S: ::serde::Serializer>(
                v: &Self,
                s: S,
            ) -> ::core::result::Result<S::Ok, S::Error> {
                ::serde::Serialize::serialize(v, s)
            }
            fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
                d: D,
            ) -> ::core::result::Result<Self, D::Error> {
                <Self as ::serde::Deserialize>::deserialize(d)
            }
        }
    };
    impl ::buffa::Enumeration for EnforceNamingStyle {
        fn from_i32(value: i32) -> ::core::option::Option<Self> {
            match value {
                0i32 => ::core::option::Option::Some(Self::ENFORCE_NAMING_STYLE_UNKNOWN),
                1i32 => ::core::option::Option::Some(Self::STYLE2024),
                2i32 => ::core::option::Option::Some(Self::STYLE_LEGACY),
                _ => ::core::option::Option::None,
            }
        }
        fn to_i32(&self) -> i32 {
            *self as i32
        }
        fn proto_name(&self) -> &'static str {
            match self {
                Self::ENFORCE_NAMING_STYLE_UNKNOWN => "ENFORCE_NAMING_STYLE_UNKNOWN",
                Self::STYLE2024 => "STYLE2024",
                Self::STYLE_LEGACY => "STYLE_LEGACY",
            }
        }
        fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
            match name {
                "ENFORCE_NAMING_STYLE_UNKNOWN" => {
                    ::core::option::Option::Some(Self::ENFORCE_NAMING_STYLE_UNKNOWN)
                }
                "STYLE2024" => ::core::option::Option::Some(Self::STYLE2024),
                "STYLE_LEGACY" => ::core::option::Option::Some(Self::STYLE_LEGACY),
                _ => ::core::option::Option::None,
            }
        }
        fn values() -> &'static [Self] {
            &[Self::ENFORCE_NAMING_STYLE_UNKNOWN, Self::STYLE2024, Self::STYLE_LEGACY]
        }
    }
    #[derive(Clone, PartialEq, Default)]
    #[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
    #[cfg_attr(feature = "json", serde(default))]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    pub struct VisibilityFeature {
        #[cfg_attr(feature = "json", serde(skip))]
        #[doc(hidden)]
        pub __buffa_unknown_fields: ::buffa::UnknownFields,
    }
    impl ::core::fmt::Debug for VisibilityFeature {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            f.debug_struct("VisibilityFeature").finish()
        }
    }
    impl VisibilityFeature {
        /// Protobuf type URL for this message, for use with `Any::pack` and
        /// `Any::unpack_if`.
        ///
        /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
        pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FeatureSet.VisibilityFeature";
    }
    ::buffa::impl_default_instance!(VisibilityFeature);
    impl ::buffa::MessageName for VisibilityFeature {
        const PACKAGE: &'static str = "google.protobuf";
        const NAME: &'static str = "FeatureSet.VisibilityFeature";
        const FULL_NAME: &'static str = "google.protobuf.FeatureSet.VisibilityFeature";
        const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FeatureSet.VisibilityFeature";
    }
    impl ::buffa::Message for VisibilityFeature {
        /// Returns the total encoded size in bytes.
        ///
        /// Accumulates in `u64` (which cannot overflow for in-memory
        /// data) and saturates to `u32` at return, so a message whose
        /// encoded size exceeds the 2 GiB protobuf limit yields a value
        /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
        /// points reject, never a silently wrapped size.
        #[allow(clippy::let_and_return)]
        fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            let mut size = 0u64;
            size += self.__buffa_unknown_fields.encoded_len() as u64;
            ::buffa::saturate_size(size)
        }
        fn write_to(
            &self,
            _cache: &mut ::buffa::SizeCache,
            buf: &mut impl ::buffa::EncodeSink,
        ) {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            self.__buffa_unknown_fields.write_to(buf);
        }
        fn merge_field(
            &mut self,
            tag: ::buffa::encoding::Tag,
            buf: &mut impl ::buffa::bytes::Buf,
            ctx: ::buffa::DecodeContext<'_>,
        ) -> ::core::result::Result<(), ::buffa::DecodeError> {
            #[allow(unused_imports)]
            use ::buffa::bytes::Buf as _;
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            match tag.field_number() {
                _ => {
                    self.__buffa_unknown_fields
                        .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
                }
            }
            ::core::result::Result::Ok(())
        }
        fn clear(&mut self) {
            self.__buffa_unknown_fields.clear();
        }
    }
    impl ::buffa::ExtensionSet for VisibilityFeature {
        const PROTO_FQN: &'static str = "google.protobuf.FeatureSet.VisibilityFeature";
        fn unknown_fields(&self) -> &::buffa::UnknownFields {
            &self.__buffa_unknown_fields
        }
        fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
            &mut self.__buffa_unknown_fields
        }
    }
    #[cfg(feature = "text")]
    impl ::buffa::text::TextFormat for VisibilityFeature {
        fn encode_text(
            &self,
            enc: &mut ::buffa::text::TextEncoder<'_>,
        ) -> ::core::fmt::Result {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
            ::core::result::Result::Ok(())
        }
        fn merge_text(
            &mut self,
            dec: &mut ::buffa::text::TextDecoder<'_>,
        ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
                match __name {
                    _ => dec.skip_value()?,
                }
            }
            ::core::result::Result::Ok(())
        }
    }
    #[cfg(feature = "json")]
    impl ::buffa::json_helpers::ProtoElemJson for VisibilityFeature {
        fn serialize_proto_json<S: ::serde::Serializer>(
            v: &Self,
            s: S,
        ) -> ::core::result::Result<S::Ok, S::Error> {
            ::serde::Serialize::serialize(v, s)
        }
        fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
            d: D,
        ) -> ::core::result::Result<Self, D::Error> {
            <Self as ::serde::Deserialize>::deserialize(d)
        }
    }
    #[cfg(feature = "json")]
    #[doc(hidden)]
    pub const __VISIBILITY_FEATURE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.FeatureSet.VisibilityFeature",
        to_json: ::buffa::type_registry::any_to_json::<VisibilityFeature>,
        from_json: ::buffa::type_registry::any_from_json::<VisibilityFeature>,
        is_wkt: false,
    };
    #[cfg(feature = "text")]
    #[doc(hidden)]
    pub const __VISIBILITY_FEATURE_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.FeatureSet.VisibilityFeature",
        text_encode: ::buffa::type_registry::any_encode_text::<VisibilityFeature>,
        text_merge: ::buffa::type_registry::any_merge_text::<VisibilityFeature>,
    };
    pub mod visibility_feature {
        #[allow(unused_imports)]
        use super::*;
        #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
        #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
        #[repr(i32)]
        pub enum DefaultSymbolVisibility {
            DEFAULT_SYMBOL_VISIBILITY_UNKNOWN = 0i32,
            /// Default pre-EDITION_2024, all UNSET visibility are export.
            EXPORT_ALL = 1i32,
            /// All top-level symbols default to export, nested default to local.
            EXPORT_TOP_LEVEL = 2i32,
            /// All symbols default to local.
            LOCAL_ALL = 3i32,
            /// All symbols local by default. Nested types cannot be exported.
            /// With special case caveat for message { enum {} reserved 1 to max; }
            /// This is the recommended setting for new protos.
            STRICT = 4i32,
        }
        impl DefaultSymbolVisibility {
            ///Idiomatic alias for [`Self::DEFAULT_SYMBOL_VISIBILITY_UNKNOWN`]; `Debug` prints the variant name.
            #[allow(non_upper_case_globals)]
            pub const DefaultSymbolVisibilityUnknown: Self = Self::DEFAULT_SYMBOL_VISIBILITY_UNKNOWN;
            ///Idiomatic alias for [`Self::EXPORT_ALL`]; `Debug` prints the variant name.
            #[allow(non_upper_case_globals)]
            pub const ExportAll: Self = Self::EXPORT_ALL;
            ///Idiomatic alias for [`Self::EXPORT_TOP_LEVEL`]; `Debug` prints the variant name.
            #[allow(non_upper_case_globals)]
            pub const ExportTopLevel: Self = Self::EXPORT_TOP_LEVEL;
            ///Idiomatic alias for [`Self::LOCAL_ALL`]; `Debug` prints the variant name.
            #[allow(non_upper_case_globals)]
            pub const LocalAll: Self = Self::LOCAL_ALL;
            ///Idiomatic alias for [`Self::STRICT`]; `Debug` prints the variant name.
            #[allow(non_upper_case_globals)]
            pub const Strict: Self = Self::STRICT;
        }
        impl ::core::default::Default for DefaultSymbolVisibility {
            fn default() -> Self {
                Self::DEFAULT_SYMBOL_VISIBILITY_UNKNOWN
            }
        }
        #[cfg(feature = "json")]
        const _: () = {
            impl ::serde::Serialize for DefaultSymbolVisibility {
                fn serialize<S: ::serde::Serializer>(
                    &self,
                    s: S,
                ) -> ::core::result::Result<S::Ok, S::Error> {
                    s.serialize_str(::buffa::Enumeration::proto_name(self))
                }
            }
            impl<'de> ::serde::Deserialize<'de> for DefaultSymbolVisibility {
                fn deserialize<D: ::serde::Deserializer<'de>>(
                    d: D,
                ) -> ::core::result::Result<Self, D::Error> {
                    struct _V;
                    impl ::serde::de::Visitor<'_> for _V {
                        type Value = DefaultSymbolVisibility;
                        fn expecting(
                            &self,
                            f: &mut ::core::fmt::Formatter<'_>,
                        ) -> ::core::fmt::Result {
                            f.write_str(
                                concat!(
                                    "a string, integer, or null for ",
                                    stringify!(DefaultSymbolVisibility)
                                ),
                            )
                        }
                        fn visit_str<E: ::serde::de::Error>(
                            self,
                            v: &str,
                        ) -> ::core::result::Result<DefaultSymbolVisibility, E> {
                            <DefaultSymbolVisibility as ::buffa::Enumeration>::from_proto_name(
                                    v,
                                )
                                .ok_or_else(|| {
                                    ::serde::de::Error::unknown_variant(v, &[])
                                })
                        }
                        fn visit_i64<E: ::serde::de::Error>(
                            self,
                            v: i64,
                        ) -> ::core::result::Result<DefaultSymbolVisibility, E> {
                            let v32 = i32::try_from(v)
                                .map_err(|_| {
                                    ::serde::de::Error::custom(
                                        ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                    )
                                })?;
                            <DefaultSymbolVisibility as ::buffa::Enumeration>::from_i32(
                                    v32,
                                )
                                .ok_or_else(|| {
                                    ::serde::de::Error::custom(
                                        ::buffa::alloc::format!("unknown enum value {v32}"),
                                    )
                                })
                        }
                        fn visit_u64<E: ::serde::de::Error>(
                            self,
                            v: u64,
                        ) -> ::core::result::Result<DefaultSymbolVisibility, E> {
                            let v32 = i32::try_from(v)
                                .map_err(|_| {
                                    ::serde::de::Error::custom(
                                        ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                    )
                                })?;
                            <DefaultSymbolVisibility as ::buffa::Enumeration>::from_i32(
                                    v32,
                                )
                                .ok_or_else(|| {
                                    ::serde::de::Error::custom(
                                        ::buffa::alloc::format!("unknown enum value {v32}"),
                                    )
                                })
                        }
                        fn visit_unit<E: ::serde::de::Error>(
                            self,
                        ) -> ::core::result::Result<DefaultSymbolVisibility, E> {
                            ::core::result::Result::Ok(
                                ::core::default::Default::default(),
                            )
                        }
                    }
                    d.deserialize_any(_V)
                }
            }
            impl ::buffa::json_helpers::ProtoElemJson for DefaultSymbolVisibility {
                fn serialize_proto_json<S: ::serde::Serializer>(
                    v: &Self,
                    s: S,
                ) -> ::core::result::Result<S::Ok, S::Error> {
                    ::serde::Serialize::serialize(v, s)
                }
                fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
                    d: D,
                ) -> ::core::result::Result<Self, D::Error> {
                    <Self as ::serde::Deserialize>::deserialize(d)
                }
            }
        };
        impl ::buffa::Enumeration for DefaultSymbolVisibility {
            fn from_i32(value: i32) -> ::core::option::Option<Self> {
                match value {
                    0i32 => {
                        ::core::option::Option::Some(
                            Self::DEFAULT_SYMBOL_VISIBILITY_UNKNOWN,
                        )
                    }
                    1i32 => ::core::option::Option::Some(Self::EXPORT_ALL),
                    2i32 => ::core::option::Option::Some(Self::EXPORT_TOP_LEVEL),
                    3i32 => ::core::option::Option::Some(Self::LOCAL_ALL),
                    4i32 => ::core::option::Option::Some(Self::STRICT),
                    _ => ::core::option::Option::None,
                }
            }
            fn to_i32(&self) -> i32 {
                *self as i32
            }
            fn proto_name(&self) -> &'static str {
                match self {
                    Self::DEFAULT_SYMBOL_VISIBILITY_UNKNOWN => {
                        "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN"
                    }
                    Self::EXPORT_ALL => "EXPORT_ALL",
                    Self::EXPORT_TOP_LEVEL => "EXPORT_TOP_LEVEL",
                    Self::LOCAL_ALL => "LOCAL_ALL",
                    Self::STRICT => "STRICT",
                }
            }
            fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
                match name {
                    "DEFAULT_SYMBOL_VISIBILITY_UNKNOWN" => {
                        ::core::option::Option::Some(
                            Self::DEFAULT_SYMBOL_VISIBILITY_UNKNOWN,
                        )
                    }
                    "EXPORT_ALL" => ::core::option::Option::Some(Self::EXPORT_ALL),
                    "EXPORT_TOP_LEVEL" => {
                        ::core::option::Option::Some(Self::EXPORT_TOP_LEVEL)
                    }
                    "LOCAL_ALL" => ::core::option::Option::Some(Self::LOCAL_ALL),
                    "STRICT" => ::core::option::Option::Some(Self::STRICT),
                    _ => ::core::option::Option::None,
                }
            }
            fn values() -> &'static [Self] {
                &[
                    Self::DEFAULT_SYMBOL_VISIBILITY_UNKNOWN,
                    Self::EXPORT_ALL,
                    Self::EXPORT_TOP_LEVEL,
                    Self::LOCAL_ALL,
                    Self::STRICT,
                ]
            }
        }
    }
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::feature_set::VisibilityFeatureView;
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::feature_set::VisibilityFeatureOwnedView;
}
/// A compiled specification for the defaults of a set of features.  These
/// messages are generated from FeatureSet extensions and can be used to seed
/// feature resolution. The resolution with this object becomes a simple search
/// for the closest matching edition, followed by proto merges.
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct FeatureSetDefaults {
    /// Field 1: `defaults`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "defaults",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub defaults: ::buffa::alloc::vec::Vec<
        feature_set_defaults::FeatureSetEditionDefault,
    >,
    /// The minimum supported edition (inclusive) when this was constructed.
    /// Editions before this will not have defaults.
    ///
    /// Field 4: `minimum_edition`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "minimumEdition",
            alias = "minimum_edition",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub minimum_edition: ::core::option::Option<Edition>,
    /// The maximum known edition (inclusive) when this was constructed. Editions
    /// after this will not have reliable defaults.
    ///
    /// Field 5: `maximum_edition`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "maximumEdition",
            alias = "maximum_edition",
            with = "::buffa::json_helpers::opt_closed_enum",
            skip_serializing_if = "::core::option::Option::is_none"
        )
    )]
    pub maximum_edition: ::core::option::Option<Edition>,
    #[cfg_attr(feature = "json", serde(skip))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for FeatureSetDefaults {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("FeatureSetDefaults")
            .field("defaults", &self.defaults)
            .field("minimum_edition", &self.minimum_edition)
            .field("maximum_edition", &self.maximum_edition)
            .finish()
    }
}
impl FeatureSetDefaults {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FeatureSetDefaults";
}
impl FeatureSetDefaults {
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::minimum_edition`] to `Some(value)`, consuming and returning `self`.
    pub fn with_minimum_edition(mut self, value: impl Into<Edition>) -> Self {
        self.minimum_edition = Some(value.into());
        self
    }
    #[must_use = "with_* setters return `self` by value; assign or chain the result"]
    #[inline]
    ///Sets [`Self::maximum_edition`] to `Some(value)`, consuming and returning `self`.
    pub fn with_maximum_edition(mut self, value: impl Into<Edition>) -> Self {
        self.maximum_edition = Some(value.into());
        self
    }
}
::buffa::impl_default_instance!(FeatureSetDefaults);
impl ::buffa::MessageName for FeatureSetDefaults {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "FeatureSetDefaults";
    const FULL_NAME: &'static str = "google.protobuf.FeatureSetDefaults";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FeatureSetDefaults";
}
impl ::buffa::Message for FeatureSetDefaults {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        for v in &self.defaults {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if let Some(ref v) = self.minimum_edition {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        if let Some(ref v) = self.maximum_edition {
            size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for v in &self.defaults {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        if let Some(ref v) = self.minimum_edition {
            ::buffa::types::put_int32_field(4u32, v.to_i32(), buf);
        }
        if let Some(ref v) = self.maximum_edition {
            ::buffa::types::put_int32_field(5u32, v.to_i32(), buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.defaults.push(elem);
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.minimum_edition = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 4u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                let __raw = ::buffa::types::decode_int32(buf)?;
                if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                    __raw,
                ) {
                    self.maximum_edition = ::core::option::Option::Some(__v);
                } else {
                    ctx.register_unknown_field()?;
                    self.__buffa_unknown_fields
                        .push(::buffa::UnknownField {
                            number: 5u32,
                            data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                        });
                }
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.defaults.clear();
        self.minimum_edition = ::core::option::Option::None;
        self.maximum_edition = ::core::option::Option::None;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for FeatureSetDefaults {
    const PROTO_FQN: &'static str = "google.protobuf.FeatureSetDefaults";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for FeatureSetDefaults {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref __v) = self.minimum_edition {
            enc.write_field_name("minimum_edition")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        if let ::core::option::Option::Some(ref __v) = self.maximum_edition {
            enc.write_field_name("maximum_edition")?;
            enc.write_enum_name(__v.proto_name())?;
        }
        for __v in &self.defaults {
            enc.write_field_name("defaults")?;
            enc.write_message(__v)?;
        }
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "minimum_edition" => {
                    self.minimum_edition = ::core::option::Option::Some(
                        dec.read_closed_enum_by_name::<Edition>()?,
                    );
                }
                "maximum_edition" => {
                    self.maximum_edition = ::core::option::Option::Some(
                        dec.read_closed_enum_by_name::<Edition>()?,
                    );
                }
                "defaults" => {
                    dec.read_repeated_into(
                        &mut self.defaults,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for FeatureSetDefaults {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __FEATURE_SET_DEFAULTS_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.FeatureSetDefaults",
    to_json: ::buffa::type_registry::any_to_json::<FeatureSetDefaults>,
    from_json: ::buffa::type_registry::any_from_json::<FeatureSetDefaults>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __FEATURE_SET_DEFAULTS_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.FeatureSetDefaults",
    text_encode: ::buffa::type_registry::any_encode_text::<FeatureSetDefaults>,
    text_merge: ::buffa::type_registry::any_merge_text::<FeatureSetDefaults>,
};
pub mod feature_set_defaults {
    #[allow(unused_imports)]
    use super::*;
    /// A map from every known edition with a unique set of defaults to its
    /// defaults. Not all editions may be contained here.  For a given edition,
    /// the defaults at the closest matching edition ordered at or before it should
    /// be used.  This field must be in strict ascending order by edition.
    #[derive(Clone, PartialEq, Default)]
    #[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
    #[cfg_attr(feature = "json", serde(default))]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    pub struct FeatureSetEditionDefault {
        /// Field 3: `edition`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "edition",
                with = "::buffa::json_helpers::opt_closed_enum",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub edition: ::core::option::Option<super::Edition>,
        /// Defaults of features that can be overridden in this edition.
        ///
        /// Field 4: `overridable_features`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "overridableFeatures",
                alias = "overridable_features",
                skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
            )
        )]
        pub overridable_features: ::buffa::MessageField<
            super::FeatureSet,
            ::buffa::Inline<super::FeatureSet>,
        >,
        /// Defaults of features that can't be overridden in this edition.
        ///
        /// Field 5: `fixed_features`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "fixedFeatures",
                alias = "fixed_features",
                skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
            )
        )]
        pub fixed_features: ::buffa::MessageField<
            super::FeatureSet,
            ::buffa::Inline<super::FeatureSet>,
        >,
        #[cfg_attr(feature = "json", serde(skip))]
        #[doc(hidden)]
        pub __buffa_unknown_fields: ::buffa::UnknownFields,
    }
    impl ::core::fmt::Debug for FeatureSetEditionDefault {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            f.debug_struct("FeatureSetEditionDefault")
                .field("edition", &self.edition)
                .field("overridable_features", &self.overridable_features)
                .field("fixed_features", &self.fixed_features)
                .finish()
        }
    }
    impl FeatureSetEditionDefault {
        /// Protobuf type URL for this message, for use with `Any::pack` and
        /// `Any::unpack_if`.
        ///
        /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
        pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault";
    }
    impl FeatureSetEditionDefault {
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::edition`] to `Some(value)`, consuming and returning `self`.
        pub fn with_edition(mut self, value: impl Into<super::Edition>) -> Self {
            self.edition = Some(value.into());
            self
        }
    }
    ::buffa::impl_default_instance!(FeatureSetEditionDefault);
    impl ::buffa::MessageName for FeatureSetEditionDefault {
        const PACKAGE: &'static str = "google.protobuf";
        const NAME: &'static str = "FeatureSetDefaults.FeatureSetEditionDefault";
        const FULL_NAME: &'static str = "google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault";
        const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault";
    }
    impl ::buffa::Message for FeatureSetEditionDefault {
        /// Returns the total encoded size in bytes.
        ///
        /// Accumulates in `u64` (which cannot overflow for in-memory
        /// data) and saturates to `u32` at return, so a message whose
        /// encoded size exceeds the 2 GiB protobuf limit yields a value
        /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
        /// points reject, never a silently wrapped size.
        #[allow(clippy::let_and_return)]
        fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            let mut size = 0u64;
            if let Some(ref v) = self.edition {
                size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
            }
            if self.overridable_features.is_set() {
                let __slot = __cache.reserve();
                let inner_size = self.overridable_features.compute_size(__cache);
                __cache.set(__slot, inner_size);
                size
                    += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                        + inner_size as u64;
            }
            if self.fixed_features.is_set() {
                let __slot = __cache.reserve();
                let inner_size = self.fixed_features.compute_size(__cache);
                __cache.set(__slot, inner_size);
                size
                    += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                        + inner_size as u64;
            }
            size += self.__buffa_unknown_fields.encoded_len() as u64;
            ::buffa::saturate_size(size)
        }
        fn write_to(
            &self,
            __cache: &mut ::buffa::SizeCache,
            buf: &mut impl ::buffa::EncodeSink,
        ) {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if let Some(ref v) = self.edition {
                ::buffa::types::put_int32_field(3u32, v.to_i32(), buf);
            }
            if self.overridable_features.is_set() {
                ::buffa::types::put_len_delimited_header(
                    4u32,
                    u64::from(__cache.consume_next()),
                    buf,
                );
                self.overridable_features.write_to(__cache, buf);
            }
            if self.fixed_features.is_set() {
                ::buffa::types::put_len_delimited_header(
                    5u32,
                    u64::from(__cache.consume_next()),
                    buf,
                );
                self.fixed_features.write_to(__cache, buf);
            }
            self.__buffa_unknown_fields.write_to(buf);
        }
        fn merge_field(
            &mut self,
            tag: ::buffa::encoding::Tag,
            buf: &mut impl ::buffa::bytes::Buf,
            ctx: ::buffa::DecodeContext<'_>,
        ) -> ::core::result::Result<(), ::buffa::DecodeError> {
            #[allow(unused_imports)]
            use ::buffa::bytes::Buf as _;
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            match tag.field_number() {
                3u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::Varint,
                    )?;
                    let __raw = ::buffa::types::decode_int32(buf)?;
                    if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                        __raw,
                    ) {
                        self.edition = ::core::option::Option::Some(__v);
                    } else {
                        ctx.register_unknown_field()?;
                        self.__buffa_unknown_fields
                            .push(::buffa::UnknownField {
                                number: 3u32,
                                data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                            });
                    }
                }
                4u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::LengthDelimited,
                    )?;
                    ::buffa::Message::merge_length_delimited(
                        self.overridable_features.get_or_insert_default(),
                        buf,
                        ctx,
                    )?;
                }
                5u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::LengthDelimited,
                    )?;
                    ::buffa::Message::merge_length_delimited(
                        self.fixed_features.get_or_insert_default(),
                        buf,
                        ctx,
                    )?;
                }
                _ => {
                    self.__buffa_unknown_fields
                        .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
                }
            }
            ::core::result::Result::Ok(())
        }
        fn clear(&mut self) {
            self.edition = ::core::option::Option::None;
            self.overridable_features = ::buffa::MessageField::none();
            self.fixed_features = ::buffa::MessageField::none();
            self.__buffa_unknown_fields.clear();
        }
    }
    impl ::buffa::ExtensionSet for FeatureSetEditionDefault {
        const PROTO_FQN: &'static str = "google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault";
        fn unknown_fields(&self) -> &::buffa::UnknownFields {
            &self.__buffa_unknown_fields
        }
        fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
            &mut self.__buffa_unknown_fields
        }
    }
    #[cfg(feature = "text")]
    impl ::buffa::text::TextFormat for FeatureSetEditionDefault {
        fn encode_text(
            &self,
            enc: &mut ::buffa::text::TextEncoder<'_>,
        ) -> ::core::fmt::Result {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if let ::core::option::Option::Some(ref __v) = self.edition {
                enc.write_field_name("edition")?;
                enc.write_enum_name(__v.proto_name())?;
            }
            if self.overridable_features.is_set() {
                enc.write_field_name("overridable_features")?;
                enc.write_message(&*self.overridable_features)?;
            }
            if self.fixed_features.is_set() {
                enc.write_field_name("fixed_features")?;
                enc.write_message(&*self.fixed_features)?;
            }
            enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
            ::core::result::Result::Ok(())
        }
        fn merge_text(
            &mut self,
            dec: &mut ::buffa::text::TextDecoder<'_>,
        ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
                match __name {
                    "edition" => {
                        self.edition = ::core::option::Option::Some(
                            dec.read_closed_enum_by_name::<super::Edition>()?,
                        );
                    }
                    "overridable_features" => {
                        dec.merge_message(
                            self.overridable_features.get_or_insert_default(),
                        )?
                    }
                    "fixed_features" => {
                        dec.merge_message(self.fixed_features.get_or_insert_default())?
                    }
                    _ => dec.skip_value()?,
                }
            }
            ::core::result::Result::Ok(())
        }
    }
    #[cfg(feature = "json")]
    impl ::buffa::json_helpers::ProtoElemJson for FeatureSetEditionDefault {
        fn serialize_proto_json<S: ::serde::Serializer>(
            v: &Self,
            s: S,
        ) -> ::core::result::Result<S::Ok, S::Error> {
            ::serde::Serialize::serialize(v, s)
        }
        fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
            d: D,
        ) -> ::core::result::Result<Self, D::Error> {
            <Self as ::serde::Deserialize>::deserialize(d)
        }
    }
    #[cfg(feature = "json")]
    #[doc(hidden)]
    pub const __FEATURE_SET_EDITION_DEFAULT_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault",
        to_json: ::buffa::type_registry::any_to_json::<FeatureSetEditionDefault>,
        from_json: ::buffa::type_registry::any_from_json::<FeatureSetEditionDefault>,
        is_wkt: false,
    };
    #[cfg(feature = "text")]
    #[doc(hidden)]
    pub const __FEATURE_SET_EDITION_DEFAULT_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault",
        text_encode: ::buffa::type_registry::any_encode_text::<FeatureSetEditionDefault>,
        text_merge: ::buffa::type_registry::any_merge_text::<FeatureSetEditionDefault>,
    };
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::feature_set_defaults::FeatureSetEditionDefaultView;
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::feature_set_defaults::FeatureSetEditionDefaultOwnedView;
}
/// ===================================================================
/// Optional source code info
///
/// Encapsulates information about the original source file from which a
/// FileDescriptorProto was generated.
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct SourceCodeInfo {
    /// A Location identifies a piece of source code in a .proto file which
    /// corresponds to a particular definition.  This information is intended
    /// to be useful to IDEs, code indexers, documentation generators, and similar
    /// tools.
    ///
    /// For example, say we have a file like:
    ///   message Foo {
    /// ```text
    /// optional string foo = 1;
    /// ```
    ///   }
    /// Let's look at just the field definition:
    ///   optional string foo = 1;
    ///   ^       ^^     ^^  ^  ^^^
    ///   a       bc     de  f  ghi
    /// We have the following locations:
    ///   span   path               represents
    ///   \[a,i)  \[ 4, 0, 2, 0 \]     The whole field definition.
    ///   \[a,b)  \[ 4, 0, 2, 0, 4 \]  The label (optional).
    ///   \[c,d)  \[ 4, 0, 2, 0, 5 \]  The type (string).
    ///   \[e,f)  \[ 4, 0, 2, 0, 1 \]  The name (foo).
    ///   \[g,h)  \[ 4, 0, 2, 0, 3 \]  The number (1).
    ///
    /// Notes:
    /// - A location may refer to a repeated field itself (i.e. not to any
    ///   particular index within it).  This is used whenever a set of elements are
    ///   logically enclosed in a single code segment.  For example, an entire
    ///   extend block (possibly containing multiple extension definitions) will
    ///   have an outer location whose path refers to the "extensions" repeated
    ///   field without an index.
    /// - Multiple locations may have the same path.  This happens when a single
    ///   logical declaration is spread out across multiple places.  The most
    ///   obvious example is the "extend" block again -- there may be multiple
    ///   extend blocks in the same scope, each of which will have the same path.
    /// - A location's span is not always a subset of its parent's span.  For
    ///   example, the "extendee" of an extension declaration appears at the
    ///   beginning of the "extend" block and is shared by all extensions within
    ///   the block.
    /// - Just because a location's span is a subset of some other location's span
    ///   does not mean that it is a descendant.  For example, a "group" defines
    ///   both a type and a field in a single declaration.  Thus, the locations
    ///   corresponding to the type and field and their components will overlap.
    /// - Code which tries to interpret locations should probably be designed to
    ///   ignore those that it doesn't understand, as more types of locations could
    ///   be recorded in the future.
    ///
    /// Field 1: `location`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "location",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub location: ::buffa::alloc::vec::Vec<source_code_info::Location>,
    #[cfg_attr(feature = "json", serde(flatten))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: __SourceCodeInfoExtJson,
}
impl ::core::fmt::Debug for SourceCodeInfo {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("SourceCodeInfo").field("location", &self.location).finish()
    }
}
impl SourceCodeInfo {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.SourceCodeInfo";
}
::buffa::impl_default_instance!(SourceCodeInfo);
impl ::buffa::MessageName for SourceCodeInfo {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "SourceCodeInfo";
    const FULL_NAME: &'static str = "google.protobuf.SourceCodeInfo";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.SourceCodeInfo";
}
impl ::buffa::Message for SourceCodeInfo {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        for v in &self.location {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for v in &self.location {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.location.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.location.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for SourceCodeInfo {
    const PROTO_FQN: &'static str = "google.protobuf.SourceCodeInfo";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for SourceCodeInfo {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for __v in &self.location {
            enc.write_field_name("location")?;
            enc.write_message(__v)?;
        }
        enc.write_extension_fields(
            "google.protobuf.SourceCodeInfo",
            &self.__buffa_unknown_fields,
        )?;
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "location" => {
                    dec.read_repeated_into(
                        &mut self.location,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                __name if __name.starts_with('[') => {
                    for __r in dec
                        .read_extension(__name, "google.protobuf.SourceCodeInfo")?
                    {
                        self.__buffa_unknown_fields.push(__r);
                    }
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl<'de> serde::Deserialize<'de> for SourceCodeInfo {
    fn deserialize<D: serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl<'de> serde::de::Visitor<'de> for _V {
            type Value = SourceCodeInfo;
            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                f.write_str("struct SourceCodeInfo")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<SourceCodeInfo, A::Error> {
                let mut __f_location: ::core::option::Option<
                    ::buffa::alloc::vec::Vec<source_code_info::Location>,
                > = None;
                let mut __ext_records: ::buffa::alloc::vec::Vec<::buffa::UnknownField> = ::buffa::alloc::vec::Vec::new();
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "location" => {
                            __f_location = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::buffa::alloc::vec::Vec<
                                        source_code_info::Location,
                                    >;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::buffa::alloc::vec::Vec<source_code_info::Location>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::null_as_default(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        __k if __k.starts_with('[') => {
                            let __v: ::buffa::serde_json::Value = map.next_value()?;
                            match ::buffa::extension_registry::deserialize_extension_key(
                                "google.protobuf.SourceCodeInfo",
                                __k,
                                __v,
                            ) {
                                ::core::option::Option::Some(
                                    ::core::result::Result::Ok(__recs),
                                ) => {
                                    for __rec in __recs {
                                        __ext_records.push(__rec);
                                    }
                                }
                                ::core::option::Option::Some(
                                    ::core::result::Result::Err(__e),
                                ) => {
                                    return ::core::result::Result::Err(
                                        <A::Error as ::serde::de::Error>::custom(__e),
                                    );
                                }
                                ::core::option::Option::None => {}
                            }
                        }
                        _ => {
                            map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                let mut __r = <SourceCodeInfo as ::core::default::Default>::default();
                if let ::core::option::Option::Some(v) = __f_location {
                    __r.location = v;
                }
                for __rec in __ext_records {
                    __r.__buffa_unknown_fields.push(__rec);
                }
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for SourceCodeInfo {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
#[derive(Clone, Debug, Default, PartialEq)]
#[repr(transparent)]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct __SourceCodeInfoExtJson(pub ::buffa::UnknownFields);
impl ::core::ops::Deref for __SourceCodeInfoExtJson {
    type Target = ::buffa::UnknownFields;
    fn deref(&self) -> &::buffa::UnknownFields {
        &self.0
    }
}
impl ::core::ops::DerefMut for __SourceCodeInfoExtJson {
    fn deref_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.0
    }
}
impl ::core::convert::From<::buffa::UnknownFields> for __SourceCodeInfoExtJson {
    fn from(u: ::buffa::UnknownFields) -> Self {
        Self(u)
    }
}
#[cfg(feature = "json")]
impl ::serde::Serialize for __SourceCodeInfoExtJson {
    fn serialize<S: ::serde::Serializer>(
        &self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::buffa::extension_registry::serialize_extensions(
            "google.protobuf.SourceCodeInfo",
            &self.0,
            s,
        )
    }
}
#[cfg(feature = "json")]
impl<'de> ::serde::Deserialize<'de> for __SourceCodeInfoExtJson {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        ::buffa::extension_registry::deserialize_extensions(
                "google.protobuf.SourceCodeInfo",
                d,
            )
            .map(Self)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __SOURCE_CODE_INFO_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.SourceCodeInfo",
    to_json: ::buffa::type_registry::any_to_json::<SourceCodeInfo>,
    from_json: ::buffa::type_registry::any_from_json::<SourceCodeInfo>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __SOURCE_CODE_INFO_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.SourceCodeInfo",
    text_encode: ::buffa::type_registry::any_encode_text::<SourceCodeInfo>,
    text_merge: ::buffa::type_registry::any_merge_text::<SourceCodeInfo>,
};
pub mod source_code_info {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, PartialEq, Default)]
    #[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
    #[cfg_attr(feature = "json", serde(default))]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    pub struct Location {
        /// Identifies which part of the FileDescriptorProto was defined at this
        /// location.
        ///
        /// Each element is a field number or an index.  They form a path from
        /// the root FileDescriptorProto to the place where the definition appears.
        /// For example, this path:
        ///   \[ 4, 3, 2, 7, 1 \]
        /// refers to:
        ///   file.message_type(3)  // 4, 3
        /// ```text
        ///   .field(7)         // 2, 7
        ///   .name()           // 1
        /// ```
        /// This is because FileDescriptorProto.message_type has field number 4:
        ///   repeated DescriptorProto message_type = 4;
        /// and DescriptorProto.field has field number 2:
        ///   repeated FieldDescriptorProto field = 2;
        /// and FieldDescriptorProto.name has field number 1:
        ///   optional string name = 1;
        ///
        /// Thus, the above path gives the location of a field name.  If we removed
        /// the last element:
        ///   \[ 4, 3, 2, 7 \]
        /// this path refers to the whole field declaration (from the beginning
        /// of the label to the terminating semicolon).
        ///
        /// Field 1: `path`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "path",
                skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
                deserialize_with = "::buffa::json_helpers::null_as_default"
            )
        )]
        pub path: ::buffa::alloc::vec::Vec<i32>,
        /// Always has exactly three or four elements: start line, start column,
        /// end line (optional, otherwise assumed same as start line), end column.
        /// These are packed into a single field for efficiency.  Note that line
        /// and column numbers are zero-based -- typically you will want to add
        /// 1 to each before displaying to a user.
        ///
        /// Field 2: `span`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "span",
                skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
                deserialize_with = "::buffa::json_helpers::null_as_default"
            )
        )]
        pub span: ::buffa::alloc::vec::Vec<i32>,
        /// If this SourceCodeInfo represents a complete declaration, these are any
        /// comments appearing before and after the declaration which appear to be
        /// attached to the declaration.
        ///
        /// A series of line comments appearing on consecutive lines, with no other
        /// tokens appearing on those lines, will be treated as a single comment.
        ///
        /// leading_detached_comments will keep paragraphs of comments that appear
        /// before (but not connected to) the current element. Each paragraph,
        /// separated by empty lines, will be one comment element in the repeated
        /// field.
        ///
        /// Only the comment content is provided; comment markers (e.g. //) are
        /// stripped out.  For block comments, leading whitespace and an asterisk
        /// will be stripped from the beginning of each line other than the first.
        /// Newlines are included in the output.
        ///
        /// Examples:
        ///
        ///   optional int32 foo = 1;  // Comment attached to foo.
        ///   // Comment attached to bar.
        ///   optional int32 bar = 2;
        ///
        ///   optional string baz = 3;
        ///   // Comment attached to baz.
        ///   // Another line attached to baz.
        ///
        ///   // Comment attached to moo.
        ///   //
        ///   // Another line attached to moo.
        ///   optional double moo = 4;
        ///
        ///   // Detached comment for corge. This is not leading or trailing comments
        ///   // to moo or corge because there are blank lines separating it from
        ///   // both.
        ///
        ///   // Detached comment for corge paragraph 2.
        ///
        ///   optional string corge = 5;
        ///   /* Block comment attached
        /// ```text
        /// * to corge.  Leading asterisks
        /// * will be removed. */
        /// ```
        ///   /* Block comment attached to
        /// ```text
        /// * grault. */
        /// ```
        ///   optional int32 grault = 6;
        ///
        ///   // ignored detached comments.
        ///
        /// Field 3: `leading_comments`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "leadingComments",
                alias = "leading_comments",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub leading_comments: ::core::option::Option<::buffa::alloc::string::String>,
        /// Field 4: `trailing_comments`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "trailingComments",
                alias = "trailing_comments",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub trailing_comments: ::core::option::Option<::buffa::alloc::string::String>,
        /// Field 6: `leading_detached_comments`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "leadingDetachedComments",
                alias = "leading_detached_comments",
                skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
                deserialize_with = "::buffa::json_helpers::null_as_default"
            )
        )]
        pub leading_detached_comments: ::buffa::alloc::vec::Vec<
            ::buffa::alloc::string::String,
        >,
        #[cfg_attr(feature = "json", serde(skip))]
        #[doc(hidden)]
        pub __buffa_unknown_fields: ::buffa::UnknownFields,
    }
    impl ::core::fmt::Debug for Location {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            f.debug_struct("Location")
                .field("path", &self.path)
                .field("span", &self.span)
                .field("leading_comments", &self.leading_comments)
                .field("trailing_comments", &self.trailing_comments)
                .field("leading_detached_comments", &self.leading_detached_comments)
                .finish()
        }
    }
    impl Location {
        /// Protobuf type URL for this message, for use with `Any::pack` and
        /// `Any::unpack_if`.
        ///
        /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
        pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.SourceCodeInfo.Location";
    }
    impl Location {
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::leading_comments`] to `Some(value)`, consuming and returning `self`.
        pub fn with_leading_comments(
            mut self,
            value: impl Into<::buffa::alloc::string::String>,
        ) -> Self {
            self.leading_comments = Some(value.into());
            self
        }
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::trailing_comments`] to `Some(value)`, consuming and returning `self`.
        pub fn with_trailing_comments(
            mut self,
            value: impl Into<::buffa::alloc::string::String>,
        ) -> Self {
            self.trailing_comments = Some(value.into());
            self
        }
    }
    ::buffa::impl_default_instance!(Location);
    impl ::buffa::MessageName for Location {
        const PACKAGE: &'static str = "google.protobuf";
        const NAME: &'static str = "SourceCodeInfo.Location";
        const FULL_NAME: &'static str = "google.protobuf.SourceCodeInfo.Location";
        const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.SourceCodeInfo.Location";
    }
    impl ::buffa::Message for Location {
        /// Returns the total encoded size in bytes.
        ///
        /// Accumulates in `u64` (which cannot overflow for in-memory
        /// data) and saturates to `u32` at return, so a message whose
        /// encoded size exceeds the 2 GiB protobuf limit yields a value
        /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
        /// points reject, never a silently wrapped size.
        #[allow(clippy::let_and_return)]
        fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            let mut size = 0u64;
            if !self.path.is_empty() {
                let payload: u64 = self
                    .path
                    .iter()
                    .map(|&v| ::buffa::types::int32_encoded_len(v) as u64)
                    .sum::<u64>();
                size += 1u64 + ::buffa::encoding::varint_len(payload) as u64 + payload;
            }
            if !self.span.is_empty() {
                let payload: u64 = self
                    .span
                    .iter()
                    .map(|&v| ::buffa::types::int32_encoded_len(v) as u64)
                    .sum::<u64>();
                size += 1u64 + ::buffa::encoding::varint_len(payload) as u64 + payload;
            }
            if let Some(ref v) = self.leading_comments {
                size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
            }
            if let Some(ref v) = self.trailing_comments {
                size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
            }
            for v in &self.leading_detached_comments {
                size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
            }
            size += self.__buffa_unknown_fields.encoded_len() as u64;
            ::buffa::saturate_size(size)
        }
        fn write_to(
            &self,
            _cache: &mut ::buffa::SizeCache,
            buf: &mut impl ::buffa::EncodeSink,
        ) {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if !self.path.is_empty() {
                let payload: u64 = self
                    .path
                    .iter()
                    .map(|&v| ::buffa::types::int32_encoded_len(v) as u64)
                    .sum::<u64>();
                ::buffa::types::put_len_delimited_header(1u32, payload, buf);
                for &v in &self.path {
                    ::buffa::types::encode_int32(v, buf);
                }
            }
            if !self.span.is_empty() {
                let payload: u64 = self
                    .span
                    .iter()
                    .map(|&v| ::buffa::types::int32_encoded_len(v) as u64)
                    .sum::<u64>();
                ::buffa::types::put_len_delimited_header(2u32, payload, buf);
                for &v in &self.span {
                    ::buffa::types::encode_int32(v, buf);
                }
            }
            if let Some(ref v) = self.leading_comments {
                ::buffa::types::put_string_field(3u32, v, buf);
            }
            if let Some(ref v) = self.trailing_comments {
                ::buffa::types::put_string_field(4u32, v, buf);
            }
            for v in &self.leading_detached_comments {
                ::buffa::types::put_string_field(6u32, v, buf);
            }
            self.__buffa_unknown_fields.write_to(buf);
        }
        fn merge_field(
            &mut self,
            tag: ::buffa::encoding::Tag,
            buf: &mut impl ::buffa::bytes::Buf,
            ctx: ::buffa::DecodeContext<'_>,
        ) -> ::core::result::Result<(), ::buffa::DecodeError> {
            #[allow(unused_imports)]
            use ::buffa::bytes::Buf as _;
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            match tag.field_number() {
                1u32 => {
                    if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
                        let len = ::buffa::encoding::decode_varint(buf)?;
                        let len = usize::try_from(len)
                            .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
                        if buf.remaining() < len {
                            return ::core::result::Result::Err(
                                ::buffa::DecodeError::UnexpectedEof,
                            );
                        }
                        if buf.chunk().len() >= len {
                            ::buffa::types::extend_packed_int32(
                                &buf.chunk()[..len],
                                &mut self.path,
                                len,
                            )?;
                            buf.advance(len);
                        } else {
                            self.path.reserve(len);
                            let mut limited = buf.take(len);
                            while limited.has_remaining() {
                                self.path
                                    .push(::buffa::types::decode_int32_packed(&mut limited)?);
                            }
                            let leftover = limited.remaining();
                            if leftover > 0 {
                                limited.advance(leftover);
                            }
                        }
                    } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
                        self.path.push(::buffa::types::decode_int32(buf)?);
                    } else {
                        return ::core::result::Result::Err(
                            ::buffa::encoding::wire_type_mismatch(
                                tag,
                                ::buffa::encoding::WireType::LengthDelimited,
                            ),
                        );
                    }
                }
                2u32 => {
                    if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
                        let len = ::buffa::encoding::decode_varint(buf)?;
                        let len = usize::try_from(len)
                            .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
                        if buf.remaining() < len {
                            return ::core::result::Result::Err(
                                ::buffa::DecodeError::UnexpectedEof,
                            );
                        }
                        if buf.chunk().len() >= len {
                            ::buffa::types::extend_packed_int32(
                                &buf.chunk()[..len],
                                &mut self.span,
                                len,
                            )?;
                            buf.advance(len);
                        } else {
                            self.span.reserve(len);
                            let mut limited = buf.take(len);
                            while limited.has_remaining() {
                                self.span
                                    .push(::buffa::types::decode_int32_packed(&mut limited)?);
                            }
                            let leftover = limited.remaining();
                            if leftover > 0 {
                                limited.advance(leftover);
                            }
                        }
                    } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
                        self.span.push(::buffa::types::decode_int32(buf)?);
                    } else {
                        return ::core::result::Result::Err(
                            ::buffa::encoding::wire_type_mismatch(
                                tag,
                                ::buffa::encoding::WireType::LengthDelimited,
                            ),
                        );
                    }
                }
                3u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::LengthDelimited,
                    )?;
                    ::buffa::types::merge_string(
                        self
                            .leading_comments
                            .get_or_insert_with(::buffa::alloc::string::String::new),
                        buf,
                    )?;
                }
                4u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::LengthDelimited,
                    )?;
                    ::buffa::types::merge_string(
                        self
                            .trailing_comments
                            .get_or_insert_with(::buffa::alloc::string::String::new),
                        buf,
                    )?;
                }
                6u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::LengthDelimited,
                    )?;
                    let __elem = ::buffa::types::decode_string(buf)?;
                    ctx.register_element_memory(
                        ::buffa::__private::element_footprint(&__elem),
                    )?;
                    self.leading_detached_comments.push(__elem);
                }
                _ => {
                    self.__buffa_unknown_fields
                        .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
                }
            }
            ::core::result::Result::Ok(())
        }
        fn clear(&mut self) {
            self.path.clear();
            self.span.clear();
            self.leading_comments = ::core::option::Option::None;
            self.trailing_comments = ::core::option::Option::None;
            self.leading_detached_comments.clear();
            self.__buffa_unknown_fields.clear();
        }
    }
    impl ::buffa::ExtensionSet for Location {
        const PROTO_FQN: &'static str = "google.protobuf.SourceCodeInfo.Location";
        fn unknown_fields(&self) -> &::buffa::UnknownFields {
            &self.__buffa_unknown_fields
        }
        fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
            &mut self.__buffa_unknown_fields
        }
    }
    #[cfg(feature = "text")]
    impl ::buffa::text::TextFormat for Location {
        fn encode_text(
            &self,
            enc: &mut ::buffa::text::TextEncoder<'_>,
        ) -> ::core::fmt::Result {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if let ::core::option::Option::Some(ref __v) = self.leading_comments {
                enc.write_field_name("leading_comments")?;
                enc.write_string(__v)?;
            }
            if let ::core::option::Option::Some(ref __v) = self.trailing_comments {
                enc.write_field_name("trailing_comments")?;
                enc.write_string(__v)?;
            }
            for __v in &self.path {
                enc.write_field_name("path")?;
                enc.write_i32(*__v)?;
            }
            for __v in &self.span {
                enc.write_field_name("span")?;
                enc.write_i32(*__v)?;
            }
            for __v in &self.leading_detached_comments {
                enc.write_field_name("leading_detached_comments")?;
                enc.write_string(__v)?;
            }
            enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
            ::core::result::Result::Ok(())
        }
        fn merge_text(
            &mut self,
            dec: &mut ::buffa::text::TextDecoder<'_>,
        ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
                match __name {
                    "leading_comments" => {
                        self.leading_comments = ::core::option::Option::Some(
                            dec.read_string()?.into_owned(),
                        );
                    }
                    "trailing_comments" => {
                        self.trailing_comments = ::core::option::Option::Some(
                            dec.read_string()?.into_owned(),
                        );
                    }
                    "path" => {
                        dec.read_repeated_into(&mut self.path, |__d| __d.read_i32())?
                    }
                    "span" => {
                        dec.read_repeated_into(&mut self.span, |__d| __d.read_i32())?
                    }
                    "leading_detached_comments" => {
                        dec.read_repeated_into(
                            &mut self.leading_detached_comments,
                            |__d| ::core::result::Result::Ok(
                                __d.read_string()?.into_owned(),
                            ),
                        )?
                    }
                    _ => dec.skip_value()?,
                }
            }
            ::core::result::Result::Ok(())
        }
    }
    #[cfg(feature = "json")]
    impl ::buffa::json_helpers::ProtoElemJson for Location {
        fn serialize_proto_json<S: ::serde::Serializer>(
            v: &Self,
            s: S,
        ) -> ::core::result::Result<S::Ok, S::Error> {
            ::serde::Serialize::serialize(v, s)
        }
        fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
            d: D,
        ) -> ::core::result::Result<Self, D::Error> {
            <Self as ::serde::Deserialize>::deserialize(d)
        }
    }
    #[cfg(feature = "json")]
    #[doc(hidden)]
    pub const __LOCATION_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.SourceCodeInfo.Location",
        to_json: ::buffa::type_registry::any_to_json::<Location>,
        from_json: ::buffa::type_registry::any_from_json::<Location>,
        is_wkt: false,
    };
    #[cfg(feature = "text")]
    #[doc(hidden)]
    pub const __LOCATION_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.SourceCodeInfo.Location",
        text_encode: ::buffa::type_registry::any_encode_text::<Location>,
        text_merge: ::buffa::type_registry::any_merge_text::<Location>,
    };
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::source_code_info::LocationView;
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::source_code_info::LocationOwnedView;
}
/// Describes the relationship between generated code and its original source
/// file. A GeneratedCodeInfo message is associated with only one generated
/// source file, but may contain references to different source .proto files.
#[derive(Clone, PartialEq, Default)]
#[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
#[cfg_attr(feature = "json", serde(default))]
#[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
pub struct GeneratedCodeInfo {
    /// An Annotation connects some span of text in generated code to an element
    /// of its generating .proto file.
    ///
    /// Field 1: `annotation`
    #[cfg_attr(
        feature = "json",
        serde(
            rename = "annotation",
            skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
            deserialize_with = "::buffa::json_helpers::null_as_default"
        )
    )]
    pub annotation: ::buffa::alloc::vec::Vec<generated_code_info::Annotation>,
    #[cfg_attr(feature = "json", serde(skip))]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for GeneratedCodeInfo {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("GeneratedCodeInfo")
            .field("annotation", &self.annotation)
            .finish()
    }
}
impl GeneratedCodeInfo {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.GeneratedCodeInfo";
}
::buffa::impl_default_instance!(GeneratedCodeInfo);
impl ::buffa::MessageName for GeneratedCodeInfo {
    const PACKAGE: &'static str = "google.protobuf";
    const NAME: &'static str = "GeneratedCodeInfo";
    const FULL_NAME: &'static str = "google.protobuf.GeneratedCodeInfo";
    const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.GeneratedCodeInfo";
}
impl ::buffa::Message for GeneratedCodeInfo {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        for v in &self.annotation {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for v in &self.annotation {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.annotation.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.annotation.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for GeneratedCodeInfo {
    const PROTO_FQN: &'static str = "google.protobuf.GeneratedCodeInfo";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
#[cfg(feature = "text")]
impl ::buffa::text::TextFormat for GeneratedCodeInfo {
    fn encode_text(
        &self,
        enc: &mut ::buffa::text::TextEncoder<'_>,
    ) -> ::core::fmt::Result {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for __v in &self.annotation {
            enc.write_field_name("annotation")?;
            enc.write_message(__v)?;
        }
        enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
        ::core::result::Result::Ok(())
    }
    fn merge_text(
        &mut self,
        dec: &mut ::buffa::text::TextDecoder<'_>,
    ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
            match __name {
                "annotation" => {
                    dec.read_repeated_into(
                        &mut self.annotation,
                        |__d| {
                            let mut __m = ::core::default::Default::default();
                            __d.merge_message(&mut __m)?;
                            ::core::result::Result::Ok(__m)
                        },
                    )?
                }
                _ => dec.skip_value()?,
            }
        }
        ::core::result::Result::Ok(())
    }
}
#[cfg(feature = "json")]
impl ::buffa::json_helpers::ProtoElemJson for GeneratedCodeInfo {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[cfg(feature = "json")]
#[doc(hidden)]
pub const __GENERATED_CODE_INFO_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.GeneratedCodeInfo",
    to_json: ::buffa::type_registry::any_to_json::<GeneratedCodeInfo>,
    from_json: ::buffa::type_registry::any_from_json::<GeneratedCodeInfo>,
    is_wkt: false,
};
#[cfg(feature = "text")]
#[doc(hidden)]
pub const __GENERATED_CODE_INFO_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
    type_url: "type.googleapis.com/google.protobuf.GeneratedCodeInfo",
    text_encode: ::buffa::type_registry::any_encode_text::<GeneratedCodeInfo>,
    text_merge: ::buffa::type_registry::any_merge_text::<GeneratedCodeInfo>,
};
pub mod generated_code_info {
    #[allow(unused_imports)]
    use super::*;
    #[derive(Clone, PartialEq, Default)]
    #[cfg_attr(feature = "json", derive(::serde::Serialize, ::serde::Deserialize))]
    #[cfg_attr(feature = "json", serde(default))]
    #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
    pub struct Annotation {
        /// Identifies the element in the original source .proto file. This field
        /// is formatted the same as SourceCodeInfo.Location.path.
        ///
        /// Field 1: `path`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "path",
                skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
                deserialize_with = "::buffa::json_helpers::null_as_default"
            )
        )]
        pub path: ::buffa::alloc::vec::Vec<i32>,
        /// Identifies the filesystem path to the original source .proto.
        ///
        /// Field 2: `source_file`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "sourceFile",
                alias = "source_file",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub source_file: ::core::option::Option<::buffa::alloc::string::String>,
        /// Identifies the starting offset in bytes in the generated code
        /// that relates to the identified object.
        ///
        /// Field 3: `begin`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "begin",
                with = "::buffa::json_helpers::opt_int32",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub begin: ::core::option::Option<i32>,
        /// Identifies the ending offset in bytes in the generated code that
        /// relates to the identified object. The end offset should be one past
        /// the last relevant byte (so the length of the text = end - begin).
        ///
        /// Field 4: `end`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "end",
                with = "::buffa::json_helpers::opt_int32",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub end: ::core::option::Option<i32>,
        /// Field 5: `semantic`
        #[cfg_attr(
            feature = "json",
            serde(
                rename = "semantic",
                with = "::buffa::json_helpers::opt_closed_enum",
                skip_serializing_if = "::core::option::Option::is_none"
            )
        )]
        pub semantic: ::core::option::Option<
            super::generated_code_info::annotation::Semantic,
        >,
        #[cfg_attr(feature = "json", serde(skip))]
        #[doc(hidden)]
        pub __buffa_unknown_fields: ::buffa::UnknownFields,
    }
    impl ::core::fmt::Debug for Annotation {
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
            f.debug_struct("Annotation")
                .field("path", &self.path)
                .field("source_file", &self.source_file)
                .field("begin", &self.begin)
                .field("end", &self.end)
                .field("semantic", &self.semantic)
                .finish()
        }
    }
    impl Annotation {
        /// Protobuf type URL for this message, for use with `Any::pack` and
        /// `Any::unpack_if`.
        ///
        /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
        pub const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.GeneratedCodeInfo.Annotation";
    }
    impl Annotation {
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::source_file`] to `Some(value)`, consuming and returning `self`.
        pub fn with_source_file(
            mut self,
            value: impl Into<::buffa::alloc::string::String>,
        ) -> Self {
            self.source_file = Some(value.into());
            self
        }
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::begin`] to `Some(value)`, consuming and returning `self`.
        pub fn with_begin(mut self, value: i32) -> Self {
            self.begin = Some(value);
            self
        }
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::end`] to `Some(value)`, consuming and returning `self`.
        pub fn with_end(mut self, value: i32) -> Self {
            self.end = Some(value);
            self
        }
        #[must_use = "with_* setters return `self` by value; assign or chain the result"]
        #[inline]
        ///Sets [`Self::semantic`] to `Some(value)`, consuming and returning `self`.
        pub fn with_semantic(
            mut self,
            value: impl Into<super::generated_code_info::annotation::Semantic>,
        ) -> Self {
            self.semantic = Some(value.into());
            self
        }
    }
    ::buffa::impl_default_instance!(Annotation);
    impl ::buffa::MessageName for Annotation {
        const PACKAGE: &'static str = "google.protobuf";
        const NAME: &'static str = "GeneratedCodeInfo.Annotation";
        const FULL_NAME: &'static str = "google.protobuf.GeneratedCodeInfo.Annotation";
        const TYPE_URL: &'static str = "type.googleapis.com/google.protobuf.GeneratedCodeInfo.Annotation";
    }
    impl ::buffa::Message for Annotation {
        /// Returns the total encoded size in bytes.
        ///
        /// Accumulates in `u64` (which cannot overflow for in-memory
        /// data) and saturates to `u32` at return, so a message whose
        /// encoded size exceeds the 2 GiB protobuf limit yields a value
        /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
        /// points reject, never a silently wrapped size.
        #[allow(clippy::let_and_return)]
        fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            let mut size = 0u64;
            if !self.path.is_empty() {
                let payload: u64 = self
                    .path
                    .iter()
                    .map(|&v| ::buffa::types::int32_encoded_len(v) as u64)
                    .sum::<u64>();
                size += 1u64 + ::buffa::encoding::varint_len(payload) as u64 + payload;
            }
            if let Some(ref v) = self.source_file {
                size += 1u64 + ::buffa::types::string_encoded_len(v) as u64;
            }
            if let Some(v) = self.begin {
                size += 1u64 + ::buffa::types::int32_encoded_len(v) as u64;
            }
            if let Some(v) = self.end {
                size += 1u64 + ::buffa::types::int32_encoded_len(v) as u64;
            }
            if let Some(ref v) = self.semantic {
                size += 1u64 + ::buffa::types::int32_encoded_len(v.to_i32()) as u64;
            }
            size += self.__buffa_unknown_fields.encoded_len() as u64;
            ::buffa::saturate_size(size)
        }
        fn write_to(
            &self,
            _cache: &mut ::buffa::SizeCache,
            buf: &mut impl ::buffa::EncodeSink,
        ) {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if !self.path.is_empty() {
                let payload: u64 = self
                    .path
                    .iter()
                    .map(|&v| ::buffa::types::int32_encoded_len(v) as u64)
                    .sum::<u64>();
                ::buffa::types::put_len_delimited_header(1u32, payload, buf);
                for &v in &self.path {
                    ::buffa::types::encode_int32(v, buf);
                }
            }
            if let Some(ref v) = self.source_file {
                ::buffa::types::put_string_field(2u32, v, buf);
            }
            if let Some(v) = self.begin {
                ::buffa::types::put_int32_field(3u32, v, buf);
            }
            if let Some(v) = self.end {
                ::buffa::types::put_int32_field(4u32, v, buf);
            }
            if let Some(ref v) = self.semantic {
                ::buffa::types::put_int32_field(5u32, v.to_i32(), buf);
            }
            self.__buffa_unknown_fields.write_to(buf);
        }
        fn merge_field(
            &mut self,
            tag: ::buffa::encoding::Tag,
            buf: &mut impl ::buffa::bytes::Buf,
            ctx: ::buffa::DecodeContext<'_>,
        ) -> ::core::result::Result<(), ::buffa::DecodeError> {
            #[allow(unused_imports)]
            use ::buffa::bytes::Buf as _;
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            match tag.field_number() {
                1u32 => {
                    if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
                        let len = ::buffa::encoding::decode_varint(buf)?;
                        let len = usize::try_from(len)
                            .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
                        if buf.remaining() < len {
                            return ::core::result::Result::Err(
                                ::buffa::DecodeError::UnexpectedEof,
                            );
                        }
                        if buf.chunk().len() >= len {
                            ::buffa::types::extend_packed_int32(
                                &buf.chunk()[..len],
                                &mut self.path,
                                len,
                            )?;
                            buf.advance(len);
                        } else {
                            self.path.reserve(len);
                            let mut limited = buf.take(len);
                            while limited.has_remaining() {
                                self.path
                                    .push(::buffa::types::decode_int32_packed(&mut limited)?);
                            }
                            let leftover = limited.remaining();
                            if leftover > 0 {
                                limited.advance(leftover);
                            }
                        }
                    } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
                        self.path.push(::buffa::types::decode_int32(buf)?);
                    } else {
                        return ::core::result::Result::Err(
                            ::buffa::encoding::wire_type_mismatch(
                                tag,
                                ::buffa::encoding::WireType::LengthDelimited,
                            ),
                        );
                    }
                }
                2u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::LengthDelimited,
                    )?;
                    ::buffa::types::merge_string(
                        self
                            .source_file
                            .get_or_insert_with(::buffa::alloc::string::String::new),
                        buf,
                    )?;
                }
                3u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::Varint,
                    )?;
                    self.begin = ::core::option::Option::Some(
                        ::buffa::types::decode_int32(buf)?,
                    );
                }
                4u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::Varint,
                    )?;
                    self.end = ::core::option::Option::Some(
                        ::buffa::types::decode_int32(buf)?,
                    );
                }
                5u32 => {
                    ::buffa::encoding::check_wire_type(
                        tag,
                        ::buffa::encoding::WireType::Varint,
                    )?;
                    let __raw = ::buffa::types::decode_int32(buf)?;
                    if let ::core::option::Option::Some(__v) = ::buffa::Enumeration::from_i32(
                        __raw,
                    ) {
                        self.semantic = ::core::option::Option::Some(__v);
                    } else {
                        ctx.register_unknown_field()?;
                        self.__buffa_unknown_fields
                            .push(::buffa::UnknownField {
                                number: 5u32,
                                data: ::buffa::UnknownFieldData::Varint(__raw as u64),
                            });
                    }
                }
                _ => {
                    self.__buffa_unknown_fields
                        .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
                }
            }
            ::core::result::Result::Ok(())
        }
        fn clear(&mut self) {
            self.path.clear();
            self.source_file = ::core::option::Option::None;
            self.begin = ::core::option::Option::None;
            self.end = ::core::option::Option::None;
            self.semantic = ::core::option::Option::None;
            self.__buffa_unknown_fields.clear();
        }
    }
    impl ::buffa::ExtensionSet for Annotation {
        const PROTO_FQN: &'static str = "google.protobuf.GeneratedCodeInfo.Annotation";
        fn unknown_fields(&self) -> &::buffa::UnknownFields {
            &self.__buffa_unknown_fields
        }
        fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
            &mut self.__buffa_unknown_fields
        }
    }
    #[cfg(feature = "text")]
    impl ::buffa::text::TextFormat for Annotation {
        fn encode_text(
            &self,
            enc: &mut ::buffa::text::TextEncoder<'_>,
        ) -> ::core::fmt::Result {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            if let ::core::option::Option::Some(ref __v) = self.source_file {
                enc.write_field_name("source_file")?;
                enc.write_string(__v)?;
            }
            if let ::core::option::Option::Some(ref __v) = self.begin {
                enc.write_field_name("begin")?;
                enc.write_i32(*__v)?;
            }
            if let ::core::option::Option::Some(ref __v) = self.end {
                enc.write_field_name("end")?;
                enc.write_i32(*__v)?;
            }
            if let ::core::option::Option::Some(ref __v) = self.semantic {
                enc.write_field_name("semantic")?;
                enc.write_enum_name(__v.proto_name())?;
            }
            for __v in &self.path {
                enc.write_field_name("path")?;
                enc.write_i32(*__v)?;
            }
            enc.write_unknown_fields(&self.__buffa_unknown_fields)?;
            ::core::result::Result::Ok(())
        }
        fn merge_text(
            &mut self,
            dec: &mut ::buffa::text::TextDecoder<'_>,
        ) -> ::core::result::Result<(), ::buffa::text::ParseError> {
            #[allow(unused_imports)]
            use ::buffa::Enumeration as _;
            while let ::core::option::Option::Some(__name) = dec.read_field_name()? {
                match __name {
                    "source_file" => {
                        self.source_file = ::core::option::Option::Some(
                            dec.read_string()?.into_owned(),
                        );
                    }
                    "begin" => self.begin = ::core::option::Option::Some(dec.read_i32()?),
                    "end" => self.end = ::core::option::Option::Some(dec.read_i32()?),
                    "semantic" => {
                        self.semantic = ::core::option::Option::Some(
                            dec
                                .read_closed_enum_by_name::<
                                    super::generated_code_info::annotation::Semantic,
                                >()?,
                        );
                    }
                    "path" => {
                        dec.read_repeated_into(&mut self.path, |__d| __d.read_i32())?
                    }
                    _ => dec.skip_value()?,
                }
            }
            ::core::result::Result::Ok(())
        }
    }
    #[cfg(feature = "json")]
    impl ::buffa::json_helpers::ProtoElemJson for Annotation {
        fn serialize_proto_json<S: ::serde::Serializer>(
            v: &Self,
            s: S,
        ) -> ::core::result::Result<S::Ok, S::Error> {
            ::serde::Serialize::serialize(v, s)
        }
        fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
            d: D,
        ) -> ::core::result::Result<Self, D::Error> {
            <Self as ::serde::Deserialize>::deserialize(d)
        }
    }
    #[cfg(feature = "json")]
    #[doc(hidden)]
    pub const __ANNOTATION_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.GeneratedCodeInfo.Annotation",
        to_json: ::buffa::type_registry::any_to_json::<Annotation>,
        from_json: ::buffa::type_registry::any_from_json::<Annotation>,
        is_wkt: false,
    };
    #[cfg(feature = "text")]
    #[doc(hidden)]
    pub const __ANNOTATION_TEXT_ANY: ::buffa::type_registry::TextAnyEntry = ::buffa::type_registry::TextAnyEntry {
        type_url: "type.googleapis.com/google.protobuf.GeneratedCodeInfo.Annotation",
        text_encode: ::buffa::type_registry::any_encode_text::<Annotation>,
        text_merge: ::buffa::type_registry::any_merge_text::<Annotation>,
    };
    pub mod annotation {
        #[allow(unused_imports)]
        use super::*;
        /// Represents the identified object's effect on the element in the original
        /// .proto file.
        #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
        #[cfg_attr(feature = "arbitrary", derive(::arbitrary::Arbitrary))]
        #[repr(i32)]
        pub enum Semantic {
            /// There is no effect or the effect is indescribable.
            NONE = 0i32,
            /// The element is set or otherwise mutated.
            SET = 1i32,
            /// An alias to the element is returned.
            ALIAS = 2i32,
        }
        impl Semantic {
            ///Idiomatic alias for [`Self::NONE`]; `Debug` prints the variant name.
            #[allow(non_upper_case_globals)]
            pub const None: Self = Self::NONE;
            ///Idiomatic alias for [`Self::SET`]; `Debug` prints the variant name.
            #[allow(non_upper_case_globals)]
            pub const Set: Self = Self::SET;
            ///Idiomatic alias for [`Self::ALIAS`]; `Debug` prints the variant name.
            #[allow(non_upper_case_globals)]
            pub const Alias: Self = Self::ALIAS;
        }
        impl ::core::default::Default for Semantic {
            fn default() -> Self {
                Self::NONE
            }
        }
        #[cfg(feature = "json")]
        const _: () = {
            impl ::serde::Serialize for Semantic {
                fn serialize<S: ::serde::Serializer>(
                    &self,
                    s: S,
                ) -> ::core::result::Result<S::Ok, S::Error> {
                    s.serialize_str(::buffa::Enumeration::proto_name(self))
                }
            }
            impl<'de> ::serde::Deserialize<'de> for Semantic {
                fn deserialize<D: ::serde::Deserializer<'de>>(
                    d: D,
                ) -> ::core::result::Result<Self, D::Error> {
                    struct _V;
                    impl ::serde::de::Visitor<'_> for _V {
                        type Value = Semantic;
                        fn expecting(
                            &self,
                            f: &mut ::core::fmt::Formatter<'_>,
                        ) -> ::core::fmt::Result {
                            f.write_str(
                                concat!(
                                    "a string, integer, or null for ", stringify!(Semantic)
                                ),
                            )
                        }
                        fn visit_str<E: ::serde::de::Error>(
                            self,
                            v: &str,
                        ) -> ::core::result::Result<Semantic, E> {
                            <Semantic as ::buffa::Enumeration>::from_proto_name(v)
                                .ok_or_else(|| {
                                    ::serde::de::Error::unknown_variant(v, &[])
                                })
                        }
                        fn visit_i64<E: ::serde::de::Error>(
                            self,
                            v: i64,
                        ) -> ::core::result::Result<Semantic, E> {
                            let v32 = i32::try_from(v)
                                .map_err(|_| {
                                    ::serde::de::Error::custom(
                                        ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                    )
                                })?;
                            <Semantic as ::buffa::Enumeration>::from_i32(v32)
                                .ok_or_else(|| {
                                    ::serde::de::Error::custom(
                                        ::buffa::alloc::format!("unknown enum value {v32}"),
                                    )
                                })
                        }
                        fn visit_u64<E: ::serde::de::Error>(
                            self,
                            v: u64,
                        ) -> ::core::result::Result<Semantic, E> {
                            let v32 = i32::try_from(v)
                                .map_err(|_| {
                                    ::serde::de::Error::custom(
                                        ::buffa::alloc::format!("enum value {v} out of i32 range"),
                                    )
                                })?;
                            <Semantic as ::buffa::Enumeration>::from_i32(v32)
                                .ok_or_else(|| {
                                    ::serde::de::Error::custom(
                                        ::buffa::alloc::format!("unknown enum value {v32}"),
                                    )
                                })
                        }
                        fn visit_unit<E: ::serde::de::Error>(
                            self,
                        ) -> ::core::result::Result<Semantic, E> {
                            ::core::result::Result::Ok(
                                ::core::default::Default::default(),
                            )
                        }
                    }
                    d.deserialize_any(_V)
                }
            }
            impl ::buffa::json_helpers::ProtoElemJson for Semantic {
                fn serialize_proto_json<S: ::serde::Serializer>(
                    v: &Self,
                    s: S,
                ) -> ::core::result::Result<S::Ok, S::Error> {
                    ::serde::Serialize::serialize(v, s)
                }
                fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
                    d: D,
                ) -> ::core::result::Result<Self, D::Error> {
                    <Self as ::serde::Deserialize>::deserialize(d)
                }
            }
        };
        impl ::buffa::Enumeration for Semantic {
            fn from_i32(value: i32) -> ::core::option::Option<Self> {
                match value {
                    0i32 => ::core::option::Option::Some(Self::NONE),
                    1i32 => ::core::option::Option::Some(Self::SET),
                    2i32 => ::core::option::Option::Some(Self::ALIAS),
                    _ => ::core::option::Option::None,
                }
            }
            fn to_i32(&self) -> i32 {
                *self as i32
            }
            fn proto_name(&self) -> &'static str {
                match self {
                    Self::NONE => "NONE",
                    Self::SET => "SET",
                    Self::ALIAS => "ALIAS",
                }
            }
            fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
                match name {
                    "NONE" => ::core::option::Option::Some(Self::NONE),
                    "SET" => ::core::option::Option::Some(Self::SET),
                    "ALIAS" => ::core::option::Option::Some(Self::ALIAS),
                    _ => ::core::option::Option::None,
                }
            }
            fn values() -> &'static [Self] {
                &[Self::NONE, Self::SET, Self::ALIAS]
            }
        }
    }
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::generated_code_info::AnnotationView;
    #[cfg(feature = "views")]
    #[doc(inline)]
    pub use super::__buffa::view::generated_code_info::AnnotationOwnedView;
}