reallyme-codec-proto 0.3.1

// @generated by buffa-codegen. DO NOT EDIT.
// source: reallyme/codec/v1/codec.proto

fn __reallyme_zeroize_unknown_fields(fields: &mut ::buffa::UnknownFields) {
    // Buffa intentionally keeps UnknownFields storage opaque. Taking the
    // collection and wiping the owned iterator's backing slice is the only
    // safe public route that clears both every value and the allocation slots
    // from which IntoIter will later drop them. No private-layout or unsafe
    // assumption is made.
    let mut owned_fields = ::core::iter::IntoIterator::into_iter(::core::mem::take(fields));
    for field in owned_fields.as_mut_slice() {
        ::zeroize::Zeroize::zeroize(&mut field.number);
        __reallyme_zeroize_unknown_field_data(&mut field.data);
    }
}

fn __reallyme_zeroize_unknown_field_data(data: &mut ::buffa::UnknownFieldData) {
    match data {
        ::buffa::UnknownFieldData::LengthDelimited(bytes) => {
            ::zeroize::Zeroize::zeroize(bytes);
            ::zeroize::Zeroize::zeroize(bytes.spare_capacity_mut());
        }
        ::buffa::UnknownFieldData::Group(fields) => {
            __reallyme_zeroize_unknown_fields(fields);
        }
        ::buffa::UnknownFieldData::Varint(value) => {
            ::zeroize::Zeroize::zeroize(value);
        }
        ::buffa::UnknownFieldData::Fixed64(value) => {
            ::zeroize::Zeroize::zeroize(value);
        }
        ::buffa::UnknownFieldData::Fixed32(value) => {
            ::zeroize::Zeroize::zeroize(value);
        }
    }
}

fn __reallyme_zeroize_message_vec<M: ::buffa::Message>(values: &mut ::buffa::alloc::vec::Vec<M>) {
    for value in values.iter_mut() {
        ::buffa::Message::clear(value);
    }
    values.clear();
    ::zeroize::Zeroize::zeroize(values.spare_capacity_mut());
}

fn __reallyme_zeroize_message_field<M: ::buffa::Message, P: ::buffa::ProtoBox<M>>(
    value: &mut ::buffa::MessageField<M, P>,
) {
    if let ::core::option::Option::Some(message) = value.as_option_mut() {
        ::buffa::Message::clear(message);
    }
    *value = ::buffa::MessageField::none();
}

// Buffa's default ProtoJSON bytes helper materializes a base64 String. For
// sensitive fields that hidden allocation would be freed without wiping. This
// wrapper streams standard padded base64 through Serializer::collect_str using
// one zeroizing stack buffer, so serde_json writes directly into the caller's
// bounded writer without creating an immutable secret-bearing String.
struct __ReallyMeSensitiveBytes<'a>(&'a [u8]);

impl ::serde::Serialize for __ReallyMeSensitiveBytes<'_> {
    fn serialize<S: ::serde::Serializer>(
        &self,
        serializer: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        serializer.collect_str(&__ReallyMeSensitiveBase64(self.0))
    }
}

struct __ReallyMeSensitiveBase64<'a>(&'a [u8]);

impl ::core::fmt::Display for __ReallyMeSensitiveBase64<'_> {
    fn fmt(&self, formatter: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        let mut encoded = ::zeroize::Zeroizing::new([0_u8; 4]);
        for chunk in self.0.chunks(3) {
            let written = ::base64::Engine::encode_slice(
                &::base64::engine::general_purpose::STANDARD,
                chunk,
                encoded.as_mut_slice(),
            )
            .map_err(|_| ::core::fmt::Error)?;
            let text = ::core::str::from_utf8(&encoded[..written])
                .map_err(|_| ::core::fmt::Error)?;
            formatter.write_str(text)?;
            ::zeroize::Zeroize::zeroize(encoded.as_mut_slice());
        }
        Ok(())
    }
}

fn __reallyme_serialize_sensitive_bytes<S: ::serde::Serializer>(
    value: &[u8],
    serializer: S,
) -> ::core::result::Result<S::Ok, S::Error> {
    ::serde::Serialize::serialize(&__ReallyMeSensitiveBytes(value), serializer)
}

enum __ReallyMeSensitiveBase64DecodeError {
    LengthOverflow,
    AllocationFailure,
    InvalidEncoding,
}

impl ::core::fmt::Display for __ReallyMeSensitiveBase64DecodeError {
    fn fmt(&self, formatter: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        formatter.write_str(match self {
            Self::LengthOverflow => "sensitive base64 length overflow",
            Self::AllocationFailure => "sensitive base64 allocation failure",
            Self::InvalidEncoding => "invalid sensitive base64 encoding",
        })
    }
}

const __REALLYME_SENSITIVE_BASE64_CONFIG: ::base64::engine::general_purpose::GeneralPurposeConfig =
    ::base64::engine::general_purpose::GeneralPurposeConfig::new()
        .with_decode_allow_trailing_bits(true)
        .with_decode_padding_mode(::base64::engine::DecodePaddingMode::Indifferent);
const __REALLYME_SENSITIVE_BASE64_STANDARD: ::base64::engine::general_purpose::GeneralPurpose =
    ::base64::engine::general_purpose::GeneralPurpose::new(
        &::base64::alphabet::STANDARD,
        __REALLYME_SENSITIVE_BASE64_CONFIG,
    );
const __REALLYME_SENSITIVE_BASE64_URL_SAFE: ::base64::engine::general_purpose::GeneralPurpose =
    ::base64::engine::general_purpose::GeneralPurpose::new(
        &::base64::alphabet::URL_SAFE,
        __REALLYME_SENSITIVE_BASE64_CONFIG,
    );

fn __reallyme_decode_sensitive_base64(
    value: &str,
) -> ::core::result::Result<
    ::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>,
    __ReallyMeSensitiveBase64DecodeError,
> {
    let groups = value
        .len()
        .checked_add(3)
        .ok_or(__ReallyMeSensitiveBase64DecodeError::LengthOverflow)?
        / 4;
    let capacity = groups
        .checked_mul(3)
        .ok_or(__ReallyMeSensitiveBase64DecodeError::LengthOverflow)?;
    let mut decoded = ::zeroize::Zeroizing::new(::buffa::alloc::vec::Vec::new());
    decoded
        .try_reserve_exact(capacity)
        .map_err(|_| __ReallyMeSensitiveBase64DecodeError::AllocationFailure)?;
    decoded.resize(capacity, 0);

    let written = match ::base64::Engine::decode_slice(
        &__REALLYME_SENSITIVE_BASE64_STANDARD,
        value.as_bytes(),
        decoded.as_mut_slice(),
    ) {
        Ok(written) => written,
        Err(_) => {
            ::zeroize::Zeroize::zeroize(decoded.as_mut_slice());
            ::base64::Engine::decode_slice(
                &__REALLYME_SENSITIVE_BASE64_URL_SAFE,
                value.as_bytes(),
                decoded.as_mut_slice(),
            )
            .map_err(|_| __ReallyMeSensitiveBase64DecodeError::InvalidEncoding)?
        }
    };
    decoded.truncate(written);
    Ok(decoded)
}

fn __reallyme_deserialize_sensitive_bytes_zeroizing<'de, D>(
    deserializer: D,
) -> ::core::result::Result<
    ::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>,
    D::Error,
>
where
    D: ::serde::Deserializer<'de>,
{
    struct Visitor;

    impl<'de> ::serde::de::Visitor<'de> for Visitor {
        type Value = ::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>;

        fn expecting(
            &self,
            formatter: &mut ::core::fmt::Formatter<'_>,
        ) -> ::core::fmt::Result {
            formatter.write_str("a base64-encoded string, or null")
        }

        fn visit_unit<E>(self) -> ::core::result::Result<Self::Value, E> {
            Ok(::zeroize::Zeroizing::new(::buffa::alloc::vec::Vec::new()))
        }

        fn visit_str<E: ::serde::de::Error>(
            self,
            value: &str,
        ) -> ::core::result::Result<Self::Value, E> {
            __reallyme_decode_sensitive_base64(value).map_err(E::custom)
        }
    }

    deserializer.deserialize_any(Visitor)
}

/// CodecError is the public, non-PII error envelope for codec boundary failures.
/// The oneof keeps base encoding, PEM, multiformat, and canonicalization
/// failures distinct while the shared CodecErrorReason enum provides stable
/// cross-language reason codes.
#[allow(non_camel_case_types)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum CodecErrorOrigin {
    CODEC_ERROR_ORIGIN_UNSPECIFIED = 0i32,
    CODEC_ERROR_ORIGIN_CALLER = 1i32,
    CODEC_ERROR_ORIGIN_PROVIDER = 2i32,
}
impl CodecErrorOrigin {
    ///Idiomatic alias for [`Self::CODEC_ERROR_ORIGIN_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Unspecified: Self = Self::CODEC_ERROR_ORIGIN_UNSPECIFIED;
    ///Idiomatic alias for [`Self::CODEC_ERROR_ORIGIN_CALLER`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Caller: Self = Self::CODEC_ERROR_ORIGIN_CALLER;
    ///Idiomatic alias for [`Self::CODEC_ERROR_ORIGIN_PROVIDER`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Provider: Self = Self::CODEC_ERROR_ORIGIN_PROVIDER;
}
impl ::core::default::Default for CodecErrorOrigin {
    fn default() -> Self {
        Self::CODEC_ERROR_ORIGIN_UNSPECIFIED
    }
}
impl ::serde::Serialize for CodecErrorOrigin {
    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 CodecErrorOrigin {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = CodecErrorOrigin;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!(
                        "a string, integer, or null for ", stringify!(CodecErrorOrigin)
                    ),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<CodecErrorOrigin, E> {
                <CodecErrorOrigin 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<CodecErrorOrigin, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom("enum value out of i32 range")
                    })?;
                <CodecErrorOrigin as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom("unknown enum value")
                    })
            }
            fn visit_u64<E: ::serde::de::Error>(
                self,
                v: u64,
            ) -> ::core::result::Result<CodecErrorOrigin, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom("enum value out of i32 range")
                    })?;
                <CodecErrorOrigin as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom("unknown enum value")
                    })
            }
            fn visit_unit<E: ::serde::de::Error>(
                self,
            ) -> ::core::result::Result<CodecErrorOrigin, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecErrorOrigin {
    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 CodecErrorOrigin {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::CODEC_ERROR_ORIGIN_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::CODEC_ERROR_ORIGIN_CALLER),
            2i32 => ::core::option::Option::Some(Self::CODEC_ERROR_ORIGIN_PROVIDER),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::CODEC_ERROR_ORIGIN_UNSPECIFIED => "CODEC_ERROR_ORIGIN_UNSPECIFIED",
            Self::CODEC_ERROR_ORIGIN_CALLER => "CODEC_ERROR_ORIGIN_CALLER",
            Self::CODEC_ERROR_ORIGIN_PROVIDER => "CODEC_ERROR_ORIGIN_PROVIDER",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "CODEC_ERROR_ORIGIN_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::CODEC_ERROR_ORIGIN_UNSPECIFIED)
            }
            "CODEC_ERROR_ORIGIN_CALLER" => {
                ::core::option::Option::Some(Self::CODEC_ERROR_ORIGIN_CALLER)
            }
            "CODEC_ERROR_ORIGIN_PROVIDER" => {
                ::core::option::Option::Some(Self::CODEC_ERROR_ORIGIN_PROVIDER)
            }
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::CODEC_ERROR_ORIGIN_UNSPECIFIED,
            Self::CODEC_ERROR_ORIGIN_CALLER,
            Self::CODEC_ERROR_ORIGIN_PROVIDER,
        ]
    }
}
/// CodecPemLabel is the typed protobuf representation of the PEM labels accepted
/// by the codec parser.
#[allow(non_camel_case_types)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum CodecPemLabel {
    CODEC_PEM_LABEL_UNSPECIFIED = 0i32,
    CODEC_PEM_LABEL_PRIVATE_KEY = 100i32,
    CODEC_PEM_LABEL_EC_PRIVATE_KEY = 110i32,
    CODEC_PEM_LABEL_PUBLIC_KEY = 120i32,
}
impl CodecPemLabel {
    ///Idiomatic alias for [`Self::CODEC_PEM_LABEL_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Unspecified: Self = Self::CODEC_PEM_LABEL_UNSPECIFIED;
    ///Idiomatic alias for [`Self::CODEC_PEM_LABEL_PRIVATE_KEY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PrivateKey: Self = Self::CODEC_PEM_LABEL_PRIVATE_KEY;
    ///Idiomatic alias for [`Self::CODEC_PEM_LABEL_EC_PRIVATE_KEY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const EcPrivateKey: Self = Self::CODEC_PEM_LABEL_EC_PRIVATE_KEY;
    ///Idiomatic alias for [`Self::CODEC_PEM_LABEL_PUBLIC_KEY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PublicKey: Self = Self::CODEC_PEM_LABEL_PUBLIC_KEY;
}
impl ::core::default::Default for CodecPemLabel {
    fn default() -> Self {
        Self::CODEC_PEM_LABEL_UNSPECIFIED
    }
}
impl ::serde::Serialize for CodecPemLabel {
    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 CodecPemLabel {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = CodecPemLabel;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!("a string, integer, or null for ", stringify!(CodecPemLabel)),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<CodecPemLabel, E> {
                <CodecPemLabel 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<CodecPemLabel, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom("enum value out of i32 range")
                    })?;
                <CodecPemLabel as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom("unknown enum value")
                    })
            }
            fn visit_u64<E: ::serde::de::Error>(
                self,
                v: u64,
            ) -> ::core::result::Result<CodecPemLabel, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom("enum value out of i32 range")
                    })?;
                <CodecPemLabel as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom("unknown enum value")
                    })
            }
            fn visit_unit<E: ::serde::de::Error>(
                self,
            ) -> ::core::result::Result<CodecPemLabel, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecPemLabel {
    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 CodecPemLabel {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::CODEC_PEM_LABEL_UNSPECIFIED),
            100i32 => ::core::option::Option::Some(Self::CODEC_PEM_LABEL_PRIVATE_KEY),
            110i32 => ::core::option::Option::Some(Self::CODEC_PEM_LABEL_EC_PRIVATE_KEY),
            120i32 => ::core::option::Option::Some(Self::CODEC_PEM_LABEL_PUBLIC_KEY),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::CODEC_PEM_LABEL_UNSPECIFIED => "CODEC_PEM_LABEL_UNSPECIFIED",
            Self::CODEC_PEM_LABEL_PRIVATE_KEY => "CODEC_PEM_LABEL_PRIVATE_KEY",
            Self::CODEC_PEM_LABEL_EC_PRIVATE_KEY => "CODEC_PEM_LABEL_EC_PRIVATE_KEY",
            Self::CODEC_PEM_LABEL_PUBLIC_KEY => "CODEC_PEM_LABEL_PUBLIC_KEY",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "CODEC_PEM_LABEL_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::CODEC_PEM_LABEL_UNSPECIFIED)
            }
            "CODEC_PEM_LABEL_PRIVATE_KEY" => {
                ::core::option::Option::Some(Self::CODEC_PEM_LABEL_PRIVATE_KEY)
            }
            "CODEC_PEM_LABEL_EC_PRIVATE_KEY" => {
                ::core::option::Option::Some(Self::CODEC_PEM_LABEL_EC_PRIVATE_KEY)
            }
            "CODEC_PEM_LABEL_PUBLIC_KEY" => {
                ::core::option::Option::Some(Self::CODEC_PEM_LABEL_PUBLIC_KEY)
            }
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::CODEC_PEM_LABEL_UNSPECIFIED,
            Self::CODEC_PEM_LABEL_PRIVATE_KEY,
            Self::CODEC_PEM_LABEL_EC_PRIVATE_KEY,
            Self::CODEC_PEM_LABEL_PUBLIC_KEY,
        ]
    }
}
#[allow(non_camel_case_types)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum CodecPemLineEnding {
    CODEC_PEM_LINE_ENDING_UNSPECIFIED = 0i32,
    CODEC_PEM_LINE_ENDING_LF = 100i32,
    CODEC_PEM_LINE_ENDING_CRLF = 110i32,
}
impl CodecPemLineEnding {
    ///Idiomatic alias for [`Self::CODEC_PEM_LINE_ENDING_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Unspecified: Self = Self::CODEC_PEM_LINE_ENDING_UNSPECIFIED;
    ///Idiomatic alias for [`Self::CODEC_PEM_LINE_ENDING_LF`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Lf: Self = Self::CODEC_PEM_LINE_ENDING_LF;
    ///Idiomatic alias for [`Self::CODEC_PEM_LINE_ENDING_CRLF`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Crlf: Self = Self::CODEC_PEM_LINE_ENDING_CRLF;
}
impl ::core::default::Default for CodecPemLineEnding {
    fn default() -> Self {
        Self::CODEC_PEM_LINE_ENDING_UNSPECIFIED
    }
}
impl ::serde::Serialize for CodecPemLineEnding {
    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 CodecPemLineEnding {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = CodecPemLineEnding;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!(
                        "a string, integer, or null for ", stringify!(CodecPemLineEnding)
                    ),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<CodecPemLineEnding, E> {
                <CodecPemLineEnding 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<CodecPemLineEnding, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom("enum value out of i32 range")
                    })?;
                <CodecPemLineEnding as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom("unknown enum value")
                    })
            }
            fn visit_u64<E: ::serde::de::Error>(
                self,
                v: u64,
            ) -> ::core::result::Result<CodecPemLineEnding, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom("enum value out of i32 range")
                    })?;
                <CodecPemLineEnding as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom("unknown enum value")
                    })
            }
            fn visit_unit<E: ::serde::de::Error>(
                self,
            ) -> ::core::result::Result<CodecPemLineEnding, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecPemLineEnding {
    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 CodecPemLineEnding {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::CODEC_PEM_LINE_ENDING_UNSPECIFIED),
            100i32 => ::core::option::Option::Some(Self::CODEC_PEM_LINE_ENDING_LF),
            110i32 => ::core::option::Option::Some(Self::CODEC_PEM_LINE_ENDING_CRLF),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::CODEC_PEM_LINE_ENDING_UNSPECIFIED => {
                "CODEC_PEM_LINE_ENDING_UNSPECIFIED"
            }
            Self::CODEC_PEM_LINE_ENDING_LF => "CODEC_PEM_LINE_ENDING_LF",
            Self::CODEC_PEM_LINE_ENDING_CRLF => "CODEC_PEM_LINE_ENDING_CRLF",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "CODEC_PEM_LINE_ENDING_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::CODEC_PEM_LINE_ENDING_UNSPECIFIED)
            }
            "CODEC_PEM_LINE_ENDING_LF" => {
                ::core::option::Option::Some(Self::CODEC_PEM_LINE_ENDING_LF)
            }
            "CODEC_PEM_LINE_ENDING_CRLF" => {
                ::core::option::Option::Some(Self::CODEC_PEM_LINE_ENDING_CRLF)
            }
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::CODEC_PEM_LINE_ENDING_UNSPECIFIED,
            Self::CODEC_PEM_LINE_ENDING_LF,
            Self::CODEC_PEM_LINE_ENDING_CRLF,
        ]
    }
}
/// CodecKeyMaterialKind classifies the material described by a multicodec
/// table entry. The enum is intentionally small and owned by this package so
/// SDKs do not pass ad hoc strings across FFI or RPC boundaries.
#[allow(non_camel_case_types)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum CodecKeyMaterialKind {
    CODEC_KEY_MATERIAL_KIND_UNSPECIFIED = 0i32,
    CODEC_KEY_MATERIAL_KIND_PUBLIC_KEY = 1i32,
    CODEC_KEY_MATERIAL_KIND_PRIVATE_KEY = 2i32,
    CODEC_KEY_MATERIAL_KIND_SYMMETRIC_KEY = 3i32,
    CODEC_KEY_MATERIAL_KIND_NOT_KEY = 4i32,
}
impl CodecKeyMaterialKind {
    ///Idiomatic alias for [`Self::CODEC_KEY_MATERIAL_KIND_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Unspecified: Self = Self::CODEC_KEY_MATERIAL_KIND_UNSPECIFIED;
    ///Idiomatic alias for [`Self::CODEC_KEY_MATERIAL_KIND_PUBLIC_KEY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PublicKey: Self = Self::CODEC_KEY_MATERIAL_KIND_PUBLIC_KEY;
    ///Idiomatic alias for [`Self::CODEC_KEY_MATERIAL_KIND_PRIVATE_KEY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PrivateKey: Self = Self::CODEC_KEY_MATERIAL_KIND_PRIVATE_KEY;
    ///Idiomatic alias for [`Self::CODEC_KEY_MATERIAL_KIND_SYMMETRIC_KEY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const SymmetricKey: Self = Self::CODEC_KEY_MATERIAL_KIND_SYMMETRIC_KEY;
    ///Idiomatic alias for [`Self::CODEC_KEY_MATERIAL_KIND_NOT_KEY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const NotKey: Self = Self::CODEC_KEY_MATERIAL_KIND_NOT_KEY;
}
impl ::core::default::Default for CodecKeyMaterialKind {
    fn default() -> Self {
        Self::CODEC_KEY_MATERIAL_KIND_UNSPECIFIED
    }
}
impl ::serde::Serialize for CodecKeyMaterialKind {
    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 CodecKeyMaterialKind {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = CodecKeyMaterialKind;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!(
                        "a string, integer, or null for ",
                        stringify!(CodecKeyMaterialKind)
                    ),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<CodecKeyMaterialKind, E> {
                <CodecKeyMaterialKind 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<CodecKeyMaterialKind, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom("enum value out of i32 range")
                    })?;
                <CodecKeyMaterialKind as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom("unknown enum value")
                    })
            }
            fn visit_u64<E: ::serde::de::Error>(
                self,
                v: u64,
            ) -> ::core::result::Result<CodecKeyMaterialKind, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom("enum value out of i32 range")
                    })?;
                <CodecKeyMaterialKind as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom("unknown enum value")
                    })
            }
            fn visit_unit<E: ::serde::de::Error>(
                self,
            ) -> ::core::result::Result<CodecKeyMaterialKind, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecKeyMaterialKind {
    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 CodecKeyMaterialKind {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => {
                ::core::option::Option::Some(Self::CODEC_KEY_MATERIAL_KIND_UNSPECIFIED)
            }
            1i32 => {
                ::core::option::Option::Some(Self::CODEC_KEY_MATERIAL_KIND_PUBLIC_KEY)
            }
            2i32 => {
                ::core::option::Option::Some(Self::CODEC_KEY_MATERIAL_KIND_PRIVATE_KEY)
            }
            3i32 => {
                ::core::option::Option::Some(Self::CODEC_KEY_MATERIAL_KIND_SYMMETRIC_KEY)
            }
            4i32 => ::core::option::Option::Some(Self::CODEC_KEY_MATERIAL_KIND_NOT_KEY),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::CODEC_KEY_MATERIAL_KIND_UNSPECIFIED => {
                "CODEC_KEY_MATERIAL_KIND_UNSPECIFIED"
            }
            Self::CODEC_KEY_MATERIAL_KIND_PUBLIC_KEY => {
                "CODEC_KEY_MATERIAL_KIND_PUBLIC_KEY"
            }
            Self::CODEC_KEY_MATERIAL_KIND_PRIVATE_KEY => {
                "CODEC_KEY_MATERIAL_KIND_PRIVATE_KEY"
            }
            Self::CODEC_KEY_MATERIAL_KIND_SYMMETRIC_KEY => {
                "CODEC_KEY_MATERIAL_KIND_SYMMETRIC_KEY"
            }
            Self::CODEC_KEY_MATERIAL_KIND_NOT_KEY => "CODEC_KEY_MATERIAL_KIND_NOT_KEY",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "CODEC_KEY_MATERIAL_KIND_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::CODEC_KEY_MATERIAL_KIND_UNSPECIFIED)
            }
            "CODEC_KEY_MATERIAL_KIND_PUBLIC_KEY" => {
                ::core::option::Option::Some(Self::CODEC_KEY_MATERIAL_KIND_PUBLIC_KEY)
            }
            "CODEC_KEY_MATERIAL_KIND_PRIVATE_KEY" => {
                ::core::option::Option::Some(Self::CODEC_KEY_MATERIAL_KIND_PRIVATE_KEY)
            }
            "CODEC_KEY_MATERIAL_KIND_SYMMETRIC_KEY" => {
                ::core::option::Option::Some(Self::CODEC_KEY_MATERIAL_KIND_SYMMETRIC_KEY)
            }
            "CODEC_KEY_MATERIAL_KIND_NOT_KEY" => {
                ::core::option::Option::Some(Self::CODEC_KEY_MATERIAL_KIND_NOT_KEY)
            }
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::CODEC_KEY_MATERIAL_KIND_UNSPECIFIED,
            Self::CODEC_KEY_MATERIAL_KIND_PUBLIC_KEY,
            Self::CODEC_KEY_MATERIAL_KIND_PRIVATE_KEY,
            Self::CODEC_KEY_MATERIAL_KIND_SYMMETRIC_KEY,
            Self::CODEC_KEY_MATERIAL_KIND_NOT_KEY,
        ]
    }
}
/// CodecTag classifies the protocol role of a multicodec table entry.
#[allow(non_camel_case_types)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum CodecTag {
    CODEC_TAG_UNSPECIFIED = 0i32,
    CODEC_TAG_ENCRYPTION = 1i32,
    CODEC_TAG_KEY = 2i32,
    CODEC_TAG_HASH = 3i32,
    CODEC_TAG_MULTIHASH = 4i32,
    CODEC_TAG_MULTIKEY = 5i32,
}
impl CodecTag {
    ///Idiomatic alias for [`Self::CODEC_TAG_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Unspecified: Self = Self::CODEC_TAG_UNSPECIFIED;
    ///Idiomatic alias for [`Self::CODEC_TAG_ENCRYPTION`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Encryption: Self = Self::CODEC_TAG_ENCRYPTION;
    ///Idiomatic alias for [`Self::CODEC_TAG_KEY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Key: Self = Self::CODEC_TAG_KEY;
    ///Idiomatic alias for [`Self::CODEC_TAG_HASH`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Hash: Self = Self::CODEC_TAG_HASH;
    ///Idiomatic alias for [`Self::CODEC_TAG_MULTIHASH`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Multihash: Self = Self::CODEC_TAG_MULTIHASH;
    ///Idiomatic alias for [`Self::CODEC_TAG_MULTIKEY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Multikey: Self = Self::CODEC_TAG_MULTIKEY;
}
impl ::core::default::Default for CodecTag {
    fn default() -> Self {
        Self::CODEC_TAG_UNSPECIFIED
    }
}
impl ::serde::Serialize for CodecTag {
    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 CodecTag {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = CodecTag;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!("a string, integer, or null for ", stringify!(CodecTag)),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<CodecTag, E> {
                <CodecTag 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<CodecTag, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom("enum value out of i32 range")
                    })?;
                <CodecTag as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom("unknown enum value")
                    })
            }
            fn visit_u64<E: ::serde::de::Error>(
                self,
                v: u64,
            ) -> ::core::result::Result<CodecTag, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom("enum value out of i32 range")
                    })?;
                <CodecTag as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom("unknown enum value")
                    })
            }
            fn visit_unit<E: ::serde::de::Error>(
                self,
            ) -> ::core::result::Result<CodecTag, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecTag {
    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 CodecTag {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::CODEC_TAG_UNSPECIFIED),
            1i32 => ::core::option::Option::Some(Self::CODEC_TAG_ENCRYPTION),
            2i32 => ::core::option::Option::Some(Self::CODEC_TAG_KEY),
            3i32 => ::core::option::Option::Some(Self::CODEC_TAG_HASH),
            4i32 => ::core::option::Option::Some(Self::CODEC_TAG_MULTIHASH),
            5i32 => ::core::option::Option::Some(Self::CODEC_TAG_MULTIKEY),
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::CODEC_TAG_UNSPECIFIED => "CODEC_TAG_UNSPECIFIED",
            Self::CODEC_TAG_ENCRYPTION => "CODEC_TAG_ENCRYPTION",
            Self::CODEC_TAG_KEY => "CODEC_TAG_KEY",
            Self::CODEC_TAG_HASH => "CODEC_TAG_HASH",
            Self::CODEC_TAG_MULTIHASH => "CODEC_TAG_MULTIHASH",
            Self::CODEC_TAG_MULTIKEY => "CODEC_TAG_MULTIKEY",
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "CODEC_TAG_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::CODEC_TAG_UNSPECIFIED)
            }
            "CODEC_TAG_ENCRYPTION" => {
                ::core::option::Option::Some(Self::CODEC_TAG_ENCRYPTION)
            }
            "CODEC_TAG_KEY" => ::core::option::Option::Some(Self::CODEC_TAG_KEY),
            "CODEC_TAG_HASH" => ::core::option::Option::Some(Self::CODEC_TAG_HASH),
            "CODEC_TAG_MULTIHASH" => {
                ::core::option::Option::Some(Self::CODEC_TAG_MULTIHASH)
            }
            "CODEC_TAG_MULTIKEY" => {
                ::core::option::Option::Some(Self::CODEC_TAG_MULTIKEY)
            }
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::CODEC_TAG_UNSPECIFIED,
            Self::CODEC_TAG_ENCRYPTION,
            Self::CODEC_TAG_KEY,
            Self::CODEC_TAG_HASH,
            Self::CODEC_TAG_MULTIHASH,
            Self::CODEC_TAG_MULTIKEY,
        ]
    }
}
/// CodecErrorReason is the component-owned reason-code enum for reallyme/codec.
/// Values are stable public boundary codes; local parser errors must map into
/// one of these before crossing RPC, SDK, FFI, storage, audit, or telemetry
/// boundaries. Numeric ranges are intentionally split by codec subpart:
///   100-199: base encodings
///   200-299: PEM armor
///   300-399: multiformats and key envelopes
///   400-499: CBOR/JCS/JSON canonicalization
///   500-599: backend and internal failures
///   600-699: caller-controlled protobuf and ProtoJSON boundary failures
#[allow(non_camel_case_types)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum CodecErrorReason {
    CODEC_ERROR_REASON_UNSPECIFIED = 0i32,
    /// Base encodings and generic byte-envelope limits.
    CODEC_ERROR_REASON_BASE_UNSUPPORTED_CODEC = 100i32,
    CODEC_ERROR_REASON_BASE_INVALID_ENCODING = 101i32,
    CODEC_ERROR_REASON_BASE_INVALID_LENGTH = 102i32,
    CODEC_ERROR_REASON_BASE_INPUT_TOO_LARGE = 103i32,
    CODEC_ERROR_REASON_BASE_OUTPUT_TOO_LARGE = 104i32,
    CODEC_ERROR_REASON_BASE_INVALID_BASE64 = 110i32,
    CODEC_ERROR_REASON_BASE_INVALID_BASE64URL = 111i32,
    CODEC_ERROR_REASON_BASE_INVALID_HEX = 120i32,
    CODEC_ERROR_REASON_BASE_NON_CANONICAL_HEX = 121i32,
    /// PEM armor.
    CODEC_ERROR_REASON_PEM_INVALID_BOUNDARY = 200i32,
    CODEC_ERROR_REASON_PEM_LABEL_MISMATCH = 201i32,
    CODEC_ERROR_REASON_PEM_UNSUPPORTED_LABEL = 202i32,
    CODEC_ERROR_REASON_PEM_INVALID_BODY = 203i32,
    CODEC_ERROR_REASON_PEM_DER_TOO_LARGE = 204i32,
    CODEC_ERROR_REASON_PEM_EMPTY_INPUT = 205i32,
    CODEC_ERROR_REASON_PEM_EMPTY_DER = 206i32,
    CODEC_ERROR_REASON_PEM_INVALID_OPTIONS = 207i32,
    CODEC_ERROR_REASON_PEM_MISSING_BEGIN = 208i32,
    CODEC_ERROR_REASON_PEM_MISSING_END = 209i32,
    CODEC_ERROR_REASON_PEM_INVALID_BASE64 = 210i32,
    /// Multiformats and key envelopes.
    CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTIBASE_PREFIX = 300i32,
    CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTICODEC_PREFIX = 301i32,
    CODEC_ERROR_REASON_MULTIFORMAT_UNKNOWN_MULTICODEC = 302i32,
    CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTIKEY = 303i32,
    /// CBOR, DAG-CBOR, JCS, and JSON canonicalization.
    CODEC_ERROR_REASON_CANONICAL_INVALID_CBOR = 400i32,
    CODEC_ERROR_REASON_CANONICAL_NON_CANONICAL_CBOR = 401i32,
    CODEC_ERROR_REASON_CANONICAL_INVALID_JSON = 402i32,
    CODEC_ERROR_REASON_CANONICAL_NON_CANONICAL_JSON = 403i32,
    CODEC_ERROR_REASON_CANONICAL_INTERNAL = 404i32,
    CODEC_ERROR_REASON_CANONICAL_NON_MINIMAL_CBOR_INTEGER = 405i32,
    CODEC_ERROR_REASON_CANONICAL_DUPLICATE_CBOR_MAP_KEY = 406i32,
    CODEC_ERROR_REASON_CANONICAL_CBOR_MAP_KEYS_OUT_OF_ORDER = 407i32,
    CODEC_ERROR_REASON_CANONICAL_CBOR_TRAILING_BYTES = 408i32,
    CODEC_ERROR_REASON_CANONICAL_UNSUPPORTED_IPLD_VALUE = 409i32,
    /// Backend failures.
    CODEC_ERROR_REASON_BACKEND_INTERNAL = 500i32,
    /// Caller-controlled wire-boundary failures.
    CODEC_ERROR_REASON_BOUNDARY_MALFORMED_PROTOBUF = 600i32,
    CODEC_ERROR_REASON_BOUNDARY_MALFORMED_JSON = 601i32,
    CODEC_ERROR_REASON_BOUNDARY_RESOURCE_LIMIT_EXCEEDED = 602i32,
    CODEC_ERROR_REASON_BOUNDARY_MISSING_OPERATION = 603i32,
}
impl CodecErrorReason {
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Unspecified: Self = Self::CODEC_ERROR_REASON_UNSPECIFIED;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_BASE_UNSUPPORTED_CODEC`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const BaseUnsupportedCodec: Self = Self::CODEC_ERROR_REASON_BASE_UNSUPPORTED_CODEC;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_BASE_INVALID_ENCODING`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const BaseInvalidEncoding: Self = Self::CODEC_ERROR_REASON_BASE_INVALID_ENCODING;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_BASE_INVALID_LENGTH`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const BaseInvalidLength: Self = Self::CODEC_ERROR_REASON_BASE_INVALID_LENGTH;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_BASE_INPUT_TOO_LARGE`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const BaseInputTooLarge: Self = Self::CODEC_ERROR_REASON_BASE_INPUT_TOO_LARGE;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_BASE_OUTPUT_TOO_LARGE`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const BaseOutputTooLarge: Self = Self::CODEC_ERROR_REASON_BASE_OUTPUT_TOO_LARGE;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_BASE_INVALID_BASE64`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const BaseInvalidBase64: Self = Self::CODEC_ERROR_REASON_BASE_INVALID_BASE64;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_BASE_INVALID_BASE64URL`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const BaseInvalidBase64url: Self = Self::CODEC_ERROR_REASON_BASE_INVALID_BASE64URL;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_BASE_INVALID_HEX`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const BaseInvalidHex: Self = Self::CODEC_ERROR_REASON_BASE_INVALID_HEX;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_BASE_NON_CANONICAL_HEX`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const BaseNonCanonicalHex: Self = Self::CODEC_ERROR_REASON_BASE_NON_CANONICAL_HEX;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_PEM_INVALID_BOUNDARY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PemInvalidBoundary: Self = Self::CODEC_ERROR_REASON_PEM_INVALID_BOUNDARY;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_PEM_LABEL_MISMATCH`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PemLabelMismatch: Self = Self::CODEC_ERROR_REASON_PEM_LABEL_MISMATCH;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_PEM_UNSUPPORTED_LABEL`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PemUnsupportedLabel: Self = Self::CODEC_ERROR_REASON_PEM_UNSUPPORTED_LABEL;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_PEM_INVALID_BODY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PemInvalidBody: Self = Self::CODEC_ERROR_REASON_PEM_INVALID_BODY;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_PEM_DER_TOO_LARGE`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PemDerTooLarge: Self = Self::CODEC_ERROR_REASON_PEM_DER_TOO_LARGE;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_PEM_EMPTY_INPUT`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PemEmptyInput: Self = Self::CODEC_ERROR_REASON_PEM_EMPTY_INPUT;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_PEM_EMPTY_DER`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PemEmptyDer: Self = Self::CODEC_ERROR_REASON_PEM_EMPTY_DER;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_PEM_INVALID_OPTIONS`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PemInvalidOptions: Self = Self::CODEC_ERROR_REASON_PEM_INVALID_OPTIONS;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_PEM_MISSING_BEGIN`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PemMissingBegin: Self = Self::CODEC_ERROR_REASON_PEM_MISSING_BEGIN;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_PEM_MISSING_END`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PemMissingEnd: Self = Self::CODEC_ERROR_REASON_PEM_MISSING_END;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_PEM_INVALID_BASE64`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const PemInvalidBase64: Self = Self::CODEC_ERROR_REASON_PEM_INVALID_BASE64;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTIBASE_PREFIX`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const MultiformatInvalidMultibasePrefix: Self = Self::CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTIBASE_PREFIX;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTICODEC_PREFIX`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const MultiformatInvalidMulticodecPrefix: Self = Self::CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTICODEC_PREFIX;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_MULTIFORMAT_UNKNOWN_MULTICODEC`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const MultiformatUnknownMulticodec: Self = Self::CODEC_ERROR_REASON_MULTIFORMAT_UNKNOWN_MULTICODEC;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTIKEY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const MultiformatInvalidMultikey: Self = Self::CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTIKEY;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_CANONICAL_INVALID_CBOR`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const CanonicalInvalidCbor: Self = Self::CODEC_ERROR_REASON_CANONICAL_INVALID_CBOR;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_CANONICAL_NON_CANONICAL_CBOR`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const CanonicalNonCanonicalCbor: Self = Self::CODEC_ERROR_REASON_CANONICAL_NON_CANONICAL_CBOR;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_CANONICAL_INVALID_JSON`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const CanonicalInvalidJson: Self = Self::CODEC_ERROR_REASON_CANONICAL_INVALID_JSON;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_CANONICAL_NON_CANONICAL_JSON`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const CanonicalNonCanonicalJson: Self = Self::CODEC_ERROR_REASON_CANONICAL_NON_CANONICAL_JSON;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_CANONICAL_INTERNAL`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const CanonicalInternal: Self = Self::CODEC_ERROR_REASON_CANONICAL_INTERNAL;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_CANONICAL_NON_MINIMAL_CBOR_INTEGER`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const CanonicalNonMinimalCborInteger: Self = Self::CODEC_ERROR_REASON_CANONICAL_NON_MINIMAL_CBOR_INTEGER;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_CANONICAL_DUPLICATE_CBOR_MAP_KEY`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const CanonicalDuplicateCborMapKey: Self = Self::CODEC_ERROR_REASON_CANONICAL_DUPLICATE_CBOR_MAP_KEY;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_CANONICAL_CBOR_MAP_KEYS_OUT_OF_ORDER`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const CanonicalCborMapKeysOutOfOrder: Self = Self::CODEC_ERROR_REASON_CANONICAL_CBOR_MAP_KEYS_OUT_OF_ORDER;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_CANONICAL_CBOR_TRAILING_BYTES`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const CanonicalCborTrailingBytes: Self = Self::CODEC_ERROR_REASON_CANONICAL_CBOR_TRAILING_BYTES;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_CANONICAL_UNSUPPORTED_IPLD_VALUE`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const CanonicalUnsupportedIpldValue: Self = Self::CODEC_ERROR_REASON_CANONICAL_UNSUPPORTED_IPLD_VALUE;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_BACKEND_INTERNAL`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const BackendInternal: Self = Self::CODEC_ERROR_REASON_BACKEND_INTERNAL;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_BOUNDARY_MALFORMED_PROTOBUF`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const BoundaryMalformedProtobuf: Self = Self::CODEC_ERROR_REASON_BOUNDARY_MALFORMED_PROTOBUF;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_BOUNDARY_MALFORMED_JSON`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const BoundaryMalformedJson: Self = Self::CODEC_ERROR_REASON_BOUNDARY_MALFORMED_JSON;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_BOUNDARY_RESOURCE_LIMIT_EXCEEDED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const BoundaryResourceLimitExceeded: Self = Self::CODEC_ERROR_REASON_BOUNDARY_RESOURCE_LIMIT_EXCEEDED;
    ///Idiomatic alias for [`Self::CODEC_ERROR_REASON_BOUNDARY_MISSING_OPERATION`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const BoundaryMissingOperation: Self = Self::CODEC_ERROR_REASON_BOUNDARY_MISSING_OPERATION;
}
impl ::core::default::Default for CodecErrorReason {
    fn default() -> Self {
        Self::CODEC_ERROR_REASON_UNSPECIFIED
    }
}
impl ::serde::Serialize for CodecErrorReason {
    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 CodecErrorReason {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = CodecErrorReason;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!(
                        "a string, integer, or null for ", stringify!(CodecErrorReason)
                    ),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<CodecErrorReason, E> {
                <CodecErrorReason 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<CodecErrorReason, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom("enum value out of i32 range")
                    })?;
                <CodecErrorReason as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom("unknown enum value")
                    })
            }
            fn visit_u64<E: ::serde::de::Error>(
                self,
                v: u64,
            ) -> ::core::result::Result<CodecErrorReason, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom("enum value out of i32 range")
                    })?;
                <CodecErrorReason as ::buffa::Enumeration>::from_i32(v32)
                    .ok_or_else(|| {
                        ::serde::de::Error::custom("unknown enum value")
                    })
            }
            fn visit_unit<E: ::serde::de::Error>(
                self,
            ) -> ::core::result::Result<CodecErrorReason, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecErrorReason {
    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 CodecErrorReason {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => ::core::option::Option::Some(Self::CODEC_ERROR_REASON_UNSPECIFIED),
            100i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BASE_UNSUPPORTED_CODEC,
                )
            }
            101i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BASE_INVALID_ENCODING,
                )
            }
            102i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BASE_INVALID_LENGTH,
                )
            }
            103i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BASE_INPUT_TOO_LARGE,
                )
            }
            104i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BASE_OUTPUT_TOO_LARGE,
                )
            }
            110i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BASE_INVALID_BASE64,
                )
            }
            111i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BASE_INVALID_BASE64URL,
                )
            }
            120i32 => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_BASE_INVALID_HEX)
            }
            121i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BASE_NON_CANONICAL_HEX,
                )
            }
            200i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_PEM_INVALID_BOUNDARY,
                )
            }
            201i32 => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_PEM_LABEL_MISMATCH)
            }
            202i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_PEM_UNSUPPORTED_LABEL,
                )
            }
            203i32 => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_PEM_INVALID_BODY)
            }
            204i32 => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_PEM_DER_TOO_LARGE)
            }
            205i32 => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_PEM_EMPTY_INPUT)
            }
            206i32 => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_PEM_EMPTY_DER)
            }
            207i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_PEM_INVALID_OPTIONS,
                )
            }
            208i32 => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_PEM_MISSING_BEGIN)
            }
            209i32 => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_PEM_MISSING_END)
            }
            210i32 => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_PEM_INVALID_BASE64)
            }
            300i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTIBASE_PREFIX,
                )
            }
            301i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTICODEC_PREFIX,
                )
            }
            302i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_MULTIFORMAT_UNKNOWN_MULTICODEC,
                )
            }
            303i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTIKEY,
                )
            }
            400i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_CANONICAL_INVALID_CBOR,
                )
            }
            401i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_CANONICAL_NON_CANONICAL_CBOR,
                )
            }
            402i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_CANONICAL_INVALID_JSON,
                )
            }
            403i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_CANONICAL_NON_CANONICAL_JSON,
                )
            }
            404i32 => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_CANONICAL_INTERNAL)
            }
            405i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_CANONICAL_NON_MINIMAL_CBOR_INTEGER,
                )
            }
            406i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_CANONICAL_DUPLICATE_CBOR_MAP_KEY,
                )
            }
            407i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_CANONICAL_CBOR_MAP_KEYS_OUT_OF_ORDER,
                )
            }
            408i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_CANONICAL_CBOR_TRAILING_BYTES,
                )
            }
            409i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_CANONICAL_UNSUPPORTED_IPLD_VALUE,
                )
            }
            500i32 => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_BACKEND_INTERNAL)
            }
            600i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BOUNDARY_MALFORMED_PROTOBUF,
                )
            }
            601i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BOUNDARY_MALFORMED_JSON,
                )
            }
            602i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BOUNDARY_RESOURCE_LIMIT_EXCEEDED,
                )
            }
            603i32 => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BOUNDARY_MISSING_OPERATION,
                )
            }
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::CODEC_ERROR_REASON_UNSPECIFIED => "CODEC_ERROR_REASON_UNSPECIFIED",
            Self::CODEC_ERROR_REASON_BASE_UNSUPPORTED_CODEC => {
                "CODEC_ERROR_REASON_BASE_UNSUPPORTED_CODEC"
            }
            Self::CODEC_ERROR_REASON_BASE_INVALID_ENCODING => {
                "CODEC_ERROR_REASON_BASE_INVALID_ENCODING"
            }
            Self::CODEC_ERROR_REASON_BASE_INVALID_LENGTH => {
                "CODEC_ERROR_REASON_BASE_INVALID_LENGTH"
            }
            Self::CODEC_ERROR_REASON_BASE_INPUT_TOO_LARGE => {
                "CODEC_ERROR_REASON_BASE_INPUT_TOO_LARGE"
            }
            Self::CODEC_ERROR_REASON_BASE_OUTPUT_TOO_LARGE => {
                "CODEC_ERROR_REASON_BASE_OUTPUT_TOO_LARGE"
            }
            Self::CODEC_ERROR_REASON_BASE_INVALID_BASE64 => {
                "CODEC_ERROR_REASON_BASE_INVALID_BASE64"
            }
            Self::CODEC_ERROR_REASON_BASE_INVALID_BASE64URL => {
                "CODEC_ERROR_REASON_BASE_INVALID_BASE64URL"
            }
            Self::CODEC_ERROR_REASON_BASE_INVALID_HEX => {
                "CODEC_ERROR_REASON_BASE_INVALID_HEX"
            }
            Self::CODEC_ERROR_REASON_BASE_NON_CANONICAL_HEX => {
                "CODEC_ERROR_REASON_BASE_NON_CANONICAL_HEX"
            }
            Self::CODEC_ERROR_REASON_PEM_INVALID_BOUNDARY => {
                "CODEC_ERROR_REASON_PEM_INVALID_BOUNDARY"
            }
            Self::CODEC_ERROR_REASON_PEM_LABEL_MISMATCH => {
                "CODEC_ERROR_REASON_PEM_LABEL_MISMATCH"
            }
            Self::CODEC_ERROR_REASON_PEM_UNSUPPORTED_LABEL => {
                "CODEC_ERROR_REASON_PEM_UNSUPPORTED_LABEL"
            }
            Self::CODEC_ERROR_REASON_PEM_INVALID_BODY => {
                "CODEC_ERROR_REASON_PEM_INVALID_BODY"
            }
            Self::CODEC_ERROR_REASON_PEM_DER_TOO_LARGE => {
                "CODEC_ERROR_REASON_PEM_DER_TOO_LARGE"
            }
            Self::CODEC_ERROR_REASON_PEM_EMPTY_INPUT => {
                "CODEC_ERROR_REASON_PEM_EMPTY_INPUT"
            }
            Self::CODEC_ERROR_REASON_PEM_EMPTY_DER => "CODEC_ERROR_REASON_PEM_EMPTY_DER",
            Self::CODEC_ERROR_REASON_PEM_INVALID_OPTIONS => {
                "CODEC_ERROR_REASON_PEM_INVALID_OPTIONS"
            }
            Self::CODEC_ERROR_REASON_PEM_MISSING_BEGIN => {
                "CODEC_ERROR_REASON_PEM_MISSING_BEGIN"
            }
            Self::CODEC_ERROR_REASON_PEM_MISSING_END => {
                "CODEC_ERROR_REASON_PEM_MISSING_END"
            }
            Self::CODEC_ERROR_REASON_PEM_INVALID_BASE64 => {
                "CODEC_ERROR_REASON_PEM_INVALID_BASE64"
            }
            Self::CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTIBASE_PREFIX => {
                "CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTIBASE_PREFIX"
            }
            Self::CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTICODEC_PREFIX => {
                "CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTICODEC_PREFIX"
            }
            Self::CODEC_ERROR_REASON_MULTIFORMAT_UNKNOWN_MULTICODEC => {
                "CODEC_ERROR_REASON_MULTIFORMAT_UNKNOWN_MULTICODEC"
            }
            Self::CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTIKEY => {
                "CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTIKEY"
            }
            Self::CODEC_ERROR_REASON_CANONICAL_INVALID_CBOR => {
                "CODEC_ERROR_REASON_CANONICAL_INVALID_CBOR"
            }
            Self::CODEC_ERROR_REASON_CANONICAL_NON_CANONICAL_CBOR => {
                "CODEC_ERROR_REASON_CANONICAL_NON_CANONICAL_CBOR"
            }
            Self::CODEC_ERROR_REASON_CANONICAL_INVALID_JSON => {
                "CODEC_ERROR_REASON_CANONICAL_INVALID_JSON"
            }
            Self::CODEC_ERROR_REASON_CANONICAL_NON_CANONICAL_JSON => {
                "CODEC_ERROR_REASON_CANONICAL_NON_CANONICAL_JSON"
            }
            Self::CODEC_ERROR_REASON_CANONICAL_INTERNAL => {
                "CODEC_ERROR_REASON_CANONICAL_INTERNAL"
            }
            Self::CODEC_ERROR_REASON_CANONICAL_NON_MINIMAL_CBOR_INTEGER => {
                "CODEC_ERROR_REASON_CANONICAL_NON_MINIMAL_CBOR_INTEGER"
            }
            Self::CODEC_ERROR_REASON_CANONICAL_DUPLICATE_CBOR_MAP_KEY => {
                "CODEC_ERROR_REASON_CANONICAL_DUPLICATE_CBOR_MAP_KEY"
            }
            Self::CODEC_ERROR_REASON_CANONICAL_CBOR_MAP_KEYS_OUT_OF_ORDER => {
                "CODEC_ERROR_REASON_CANONICAL_CBOR_MAP_KEYS_OUT_OF_ORDER"
            }
            Self::CODEC_ERROR_REASON_CANONICAL_CBOR_TRAILING_BYTES => {
                "CODEC_ERROR_REASON_CANONICAL_CBOR_TRAILING_BYTES"
            }
            Self::CODEC_ERROR_REASON_CANONICAL_UNSUPPORTED_IPLD_VALUE => {
                "CODEC_ERROR_REASON_CANONICAL_UNSUPPORTED_IPLD_VALUE"
            }
            Self::CODEC_ERROR_REASON_BACKEND_INTERNAL => {
                "CODEC_ERROR_REASON_BACKEND_INTERNAL"
            }
            Self::CODEC_ERROR_REASON_BOUNDARY_MALFORMED_PROTOBUF => {
                "CODEC_ERROR_REASON_BOUNDARY_MALFORMED_PROTOBUF"
            }
            Self::CODEC_ERROR_REASON_BOUNDARY_MALFORMED_JSON => {
                "CODEC_ERROR_REASON_BOUNDARY_MALFORMED_JSON"
            }
            Self::CODEC_ERROR_REASON_BOUNDARY_RESOURCE_LIMIT_EXCEEDED => {
                "CODEC_ERROR_REASON_BOUNDARY_RESOURCE_LIMIT_EXCEEDED"
            }
            Self::CODEC_ERROR_REASON_BOUNDARY_MISSING_OPERATION => {
                "CODEC_ERROR_REASON_BOUNDARY_MISSING_OPERATION"
            }
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "CODEC_ERROR_REASON_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_UNSPECIFIED)
            }
            "CODEC_ERROR_REASON_BASE_UNSUPPORTED_CODEC" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BASE_UNSUPPORTED_CODEC,
                )
            }
            "CODEC_ERROR_REASON_BASE_INVALID_ENCODING" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BASE_INVALID_ENCODING,
                )
            }
            "CODEC_ERROR_REASON_BASE_INVALID_LENGTH" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BASE_INVALID_LENGTH,
                )
            }
            "CODEC_ERROR_REASON_BASE_INPUT_TOO_LARGE" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BASE_INPUT_TOO_LARGE,
                )
            }
            "CODEC_ERROR_REASON_BASE_OUTPUT_TOO_LARGE" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BASE_OUTPUT_TOO_LARGE,
                )
            }
            "CODEC_ERROR_REASON_BASE_INVALID_BASE64" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BASE_INVALID_BASE64,
                )
            }
            "CODEC_ERROR_REASON_BASE_INVALID_BASE64URL" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BASE_INVALID_BASE64URL,
                )
            }
            "CODEC_ERROR_REASON_BASE_INVALID_HEX" => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_BASE_INVALID_HEX)
            }
            "CODEC_ERROR_REASON_BASE_NON_CANONICAL_HEX" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BASE_NON_CANONICAL_HEX,
                )
            }
            "CODEC_ERROR_REASON_PEM_INVALID_BOUNDARY" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_PEM_INVALID_BOUNDARY,
                )
            }
            "CODEC_ERROR_REASON_PEM_LABEL_MISMATCH" => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_PEM_LABEL_MISMATCH)
            }
            "CODEC_ERROR_REASON_PEM_UNSUPPORTED_LABEL" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_PEM_UNSUPPORTED_LABEL,
                )
            }
            "CODEC_ERROR_REASON_PEM_INVALID_BODY" => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_PEM_INVALID_BODY)
            }
            "CODEC_ERROR_REASON_PEM_DER_TOO_LARGE" => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_PEM_DER_TOO_LARGE)
            }
            "CODEC_ERROR_REASON_PEM_EMPTY_INPUT" => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_PEM_EMPTY_INPUT)
            }
            "CODEC_ERROR_REASON_PEM_EMPTY_DER" => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_PEM_EMPTY_DER)
            }
            "CODEC_ERROR_REASON_PEM_INVALID_OPTIONS" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_PEM_INVALID_OPTIONS,
                )
            }
            "CODEC_ERROR_REASON_PEM_MISSING_BEGIN" => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_PEM_MISSING_BEGIN)
            }
            "CODEC_ERROR_REASON_PEM_MISSING_END" => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_PEM_MISSING_END)
            }
            "CODEC_ERROR_REASON_PEM_INVALID_BASE64" => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_PEM_INVALID_BASE64)
            }
            "CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTIBASE_PREFIX" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTIBASE_PREFIX,
                )
            }
            "CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTICODEC_PREFIX" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTICODEC_PREFIX,
                )
            }
            "CODEC_ERROR_REASON_MULTIFORMAT_UNKNOWN_MULTICODEC" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_MULTIFORMAT_UNKNOWN_MULTICODEC,
                )
            }
            "CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTIKEY" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTIKEY,
                )
            }
            "CODEC_ERROR_REASON_CANONICAL_INVALID_CBOR" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_CANONICAL_INVALID_CBOR,
                )
            }
            "CODEC_ERROR_REASON_CANONICAL_NON_CANONICAL_CBOR" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_CANONICAL_NON_CANONICAL_CBOR,
                )
            }
            "CODEC_ERROR_REASON_CANONICAL_INVALID_JSON" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_CANONICAL_INVALID_JSON,
                )
            }
            "CODEC_ERROR_REASON_CANONICAL_NON_CANONICAL_JSON" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_CANONICAL_NON_CANONICAL_JSON,
                )
            }
            "CODEC_ERROR_REASON_CANONICAL_INTERNAL" => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_CANONICAL_INTERNAL)
            }
            "CODEC_ERROR_REASON_CANONICAL_NON_MINIMAL_CBOR_INTEGER" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_CANONICAL_NON_MINIMAL_CBOR_INTEGER,
                )
            }
            "CODEC_ERROR_REASON_CANONICAL_DUPLICATE_CBOR_MAP_KEY" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_CANONICAL_DUPLICATE_CBOR_MAP_KEY,
                )
            }
            "CODEC_ERROR_REASON_CANONICAL_CBOR_MAP_KEYS_OUT_OF_ORDER" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_CANONICAL_CBOR_MAP_KEYS_OUT_OF_ORDER,
                )
            }
            "CODEC_ERROR_REASON_CANONICAL_CBOR_TRAILING_BYTES" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_CANONICAL_CBOR_TRAILING_BYTES,
                )
            }
            "CODEC_ERROR_REASON_CANONICAL_UNSUPPORTED_IPLD_VALUE" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_CANONICAL_UNSUPPORTED_IPLD_VALUE,
                )
            }
            "CODEC_ERROR_REASON_BACKEND_INTERNAL" => {
                ::core::option::Option::Some(Self::CODEC_ERROR_REASON_BACKEND_INTERNAL)
            }
            "CODEC_ERROR_REASON_BOUNDARY_MALFORMED_PROTOBUF" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BOUNDARY_MALFORMED_PROTOBUF,
                )
            }
            "CODEC_ERROR_REASON_BOUNDARY_MALFORMED_JSON" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BOUNDARY_MALFORMED_JSON,
                )
            }
            "CODEC_ERROR_REASON_BOUNDARY_RESOURCE_LIMIT_EXCEEDED" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BOUNDARY_RESOURCE_LIMIT_EXCEEDED,
                )
            }
            "CODEC_ERROR_REASON_BOUNDARY_MISSING_OPERATION" => {
                ::core::option::Option::Some(
                    Self::CODEC_ERROR_REASON_BOUNDARY_MISSING_OPERATION,
                )
            }
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::CODEC_ERROR_REASON_UNSPECIFIED,
            Self::CODEC_ERROR_REASON_BASE_UNSUPPORTED_CODEC,
            Self::CODEC_ERROR_REASON_BASE_INVALID_ENCODING,
            Self::CODEC_ERROR_REASON_BASE_INVALID_LENGTH,
            Self::CODEC_ERROR_REASON_BASE_INPUT_TOO_LARGE,
            Self::CODEC_ERROR_REASON_BASE_OUTPUT_TOO_LARGE,
            Self::CODEC_ERROR_REASON_BASE_INVALID_BASE64,
            Self::CODEC_ERROR_REASON_BASE_INVALID_BASE64URL,
            Self::CODEC_ERROR_REASON_BASE_INVALID_HEX,
            Self::CODEC_ERROR_REASON_BASE_NON_CANONICAL_HEX,
            Self::CODEC_ERROR_REASON_PEM_INVALID_BOUNDARY,
            Self::CODEC_ERROR_REASON_PEM_LABEL_MISMATCH,
            Self::CODEC_ERROR_REASON_PEM_UNSUPPORTED_LABEL,
            Self::CODEC_ERROR_REASON_PEM_INVALID_BODY,
            Self::CODEC_ERROR_REASON_PEM_DER_TOO_LARGE,
            Self::CODEC_ERROR_REASON_PEM_EMPTY_INPUT,
            Self::CODEC_ERROR_REASON_PEM_EMPTY_DER,
            Self::CODEC_ERROR_REASON_PEM_INVALID_OPTIONS,
            Self::CODEC_ERROR_REASON_PEM_MISSING_BEGIN,
            Self::CODEC_ERROR_REASON_PEM_MISSING_END,
            Self::CODEC_ERROR_REASON_PEM_INVALID_BASE64,
            Self::CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTIBASE_PREFIX,
            Self::CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTICODEC_PREFIX,
            Self::CODEC_ERROR_REASON_MULTIFORMAT_UNKNOWN_MULTICODEC,
            Self::CODEC_ERROR_REASON_MULTIFORMAT_INVALID_MULTIKEY,
            Self::CODEC_ERROR_REASON_CANONICAL_INVALID_CBOR,
            Self::CODEC_ERROR_REASON_CANONICAL_NON_CANONICAL_CBOR,
            Self::CODEC_ERROR_REASON_CANONICAL_INVALID_JSON,
            Self::CODEC_ERROR_REASON_CANONICAL_NON_CANONICAL_JSON,
            Self::CODEC_ERROR_REASON_CANONICAL_INTERNAL,
            Self::CODEC_ERROR_REASON_CANONICAL_NON_MINIMAL_CBOR_INTEGER,
            Self::CODEC_ERROR_REASON_CANONICAL_DUPLICATE_CBOR_MAP_KEY,
            Self::CODEC_ERROR_REASON_CANONICAL_CBOR_MAP_KEYS_OUT_OF_ORDER,
            Self::CODEC_ERROR_REASON_CANONICAL_CBOR_TRAILING_BYTES,
            Self::CODEC_ERROR_REASON_CANONICAL_UNSUPPORTED_IPLD_VALUE,
            Self::CODEC_ERROR_REASON_BACKEND_INTERNAL,
            Self::CODEC_ERROR_REASON_BOUNDARY_MALFORMED_PROTOBUF,
            Self::CODEC_ERROR_REASON_BOUNDARY_MALFORMED_JSON,
            Self::CODEC_ERROR_REASON_BOUNDARY_RESOURCE_LIMIT_EXCEEDED,
            Self::CODEC_ERROR_REASON_BOUNDARY_MISSING_OPERATION,
        ]
    }
}
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecError {
    /// Error origin is explicit so SDKs never infer caller-versus-provider
    /// attribution from branch-specific numeric reason ranges. Missing, unknown,
    /// or inconsistent origin values must fail closed as provider failures.
    ///
    /// Field 100: `origin`
    #[serde(
        rename = "origin",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub origin: ::buffa::EnumValue<CodecErrorOrigin>,
    #[serde(flatten)]
    pub error: ::core::option::Option<__buffa::oneof::codec_error::Error>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecError {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecError")
            .field("origin", &self.origin)
            .field("error", &self.error)
            .finish()
    }
}
impl CodecError {
    /// 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/reallyme.codec.v1.CodecError";
}
::buffa::impl_default_instance!(CodecError);
impl ::buffa::MessageName for CodecError {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecError";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecError";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecError";
}
impl ::buffa::Message for CodecError {
    /// 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 ::core::option::Option::Some(ref v) = self.error {
            match v {
                __buffa::oneof::codec_error::Error::BaseEncoding(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_error::Error::Pem(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_error::Error::Multiformat(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_error::Error::Canonicalization(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_error::Error::Backend(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_error::Error::Boundary(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
            }
        }
        {
            let val = self.origin.to_i32();
            if val != 0 {
                size += 2u64 + ::buffa::types::int32_encoded_len(val) 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 ::core::option::Option::Some(ref v) = self.error {
            match v {
                __buffa::oneof::codec_error::Error::BaseEncoding(x) => {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_error::Error::Pem(x) => {
                    ::buffa::types::put_len_delimited_header(
                        2u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_error::Error::Multiformat(x) => {
                    ::buffa::types::put_len_delimited_header(
                        3u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_error::Error::Canonicalization(x) => {
                    ::buffa::types::put_len_delimited_header(
                        4u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_error::Error::Backend(x) => {
                    ::buffa::types::put_len_delimited_header(
                        5u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_error::Error::Boundary(x) => {
                    ::buffa::types::put_len_delimited_header(
                        6u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
            }
        }
        {
            let val = self.origin.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(100u32, val, 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,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_error::Error::BaseEncoding(ref mut existing),
                ) = self.error
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.error = ::core::option::Option::Some(
                        __buffa::oneof::codec_error::Error::BaseEncoding(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_error::Error::Pem(ref mut existing),
                ) = self.error
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.error = ::core::option::Option::Some(
                        __buffa::oneof::codec_error::Error::Pem(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_error::Error::Multiformat(ref mut existing),
                ) = self.error
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.error = ::core::option::Option::Some(
                        __buffa::oneof::codec_error::Error::Multiformat(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_error::Error::Canonicalization(
                        ref mut existing,
                    ),
                ) = self.error
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.error = ::core::option::Option::Some(
                        __buffa::oneof::codec_error::Error::Canonicalization(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_error::Error::Backend(ref mut existing),
                ) = self.error
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.error = ::core::option::Option::Some(
                        __buffa::oneof::codec_error::Error::Backend(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_error::Error::Boundary(ref mut existing),
                ) = self.error
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.error = ::core::option::Option::Some(
                        __buffa::oneof::codec_error::Error::Boundary(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            100u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.origin = ::buffa::EnumValue::from(
                    ::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.error = ::core::option::Option::None;
        self.origin = ::buffa::EnumValue::from(0);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecError {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecError";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl<'de> ::serde::Deserialize<'de> for CodecError {
    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 = CodecError;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str("struct CodecError")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: ::serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<CodecError, A::Error> {
                let mut __f_origin: ::core::option::Option<
                    ::buffa::EnumValue<CodecErrorOrigin>,
                > = None;
                let mut __oneof_error: ::core::option::Option<
                    __buffa::oneof::codec_error::Error,
                > = None;
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "origin" => {
                            __f_origin = Some({
                                struct _S;
                                impl<'de> ::serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::buffa::EnumValue<CodecErrorOrigin>;
                                    fn deserialize<D: ::serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::buffa::EnumValue<CodecErrorOrigin>,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::proto_enum::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "baseEncoding" | "base_encoding" => {
                            let v: ::core::option::Option<CodecBaseEncodingError> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecBaseEncodingError,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_error.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'error'",
                                        ),
                                    );
                                }
                                __oneof_error = Some(
                                    __buffa::oneof::codec_error::Error::BaseEncoding(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "pem" => {
                            let v: ::core::option::Option<CodecPemError> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecPemError,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_error.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'error'",
                                        ),
                                    );
                                }
                                __oneof_error = Some(
                                    __buffa::oneof::codec_error::Error::Pem(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "multiformat" => {
                            let v: ::core::option::Option<CodecMultiformatError> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecMultiformatError,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_error.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'error'",
                                        ),
                                    );
                                }
                                __oneof_error = Some(
                                    __buffa::oneof::codec_error::Error::Multiformat(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "canonicalization" => {
                            let v: ::core::option::Option<CodecCanonicalizationError> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecCanonicalizationError,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_error.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'error'",
                                        ),
                                    );
                                }
                                __oneof_error = Some(
                                    __buffa::oneof::codec_error::Error::Canonicalization(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "backend" => {
                            let v: ::core::option::Option<CodecBackendError> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecBackendError,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_error.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'error'",
                                        ),
                                    );
                                }
                                __oneof_error = Some(
                                    __buffa::oneof::codec_error::Error::Backend(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "boundary" => {
                            let v: ::core::option::Option<CodecBoundaryError> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecBoundaryError,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_error.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'error'",
                                        ),
                                    );
                                }
                                __oneof_error = Some(
                                    __buffa::oneof::codec_error::Error::Boundary(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        _ => {
                            return Err(::serde::de::Error::custom("unknown field"));
                        }
                    }
                }
                let mut __r = <CodecError as ::core::default::Default>::default();
                if let ::core::option::Option::Some(v) = __f_origin {
                    __r.origin = v;
                }
                __r.error = __oneof_error;
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecError {
    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)]
pub const __CODEC_ERROR_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecError",
    to_json: ::buffa::type_registry::any_to_json::<CodecError>,
    from_json: ::buffa::type_registry::any_from_json::<CodecError>,
    is_wkt: false,
};
pub mod codec_error {
    #[allow(unused_imports)]
    use super::*;
    #[doc(inline)]
    pub use super::__buffa::oneof::codec_error::Error;
    #[doc(inline)]
    pub use super::__buffa::view::oneof::codec_error::Error as ErrorView;
}
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecMulticodecPrefixForNameRequest {
    /// Field 1: `name`
    #[serde(
        rename = "name",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub name: ::buffa::alloc::string::String,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecMulticodecPrefixForNameRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecMulticodecPrefixForNameRequest")
            .field("name", &self.name)
            .finish()
    }
}
impl CodecMulticodecPrefixForNameRequest {
    /// 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/reallyme.codec.v1.CodecMulticodecPrefixForNameRequest";
}
::buffa::impl_default_instance!(CodecMulticodecPrefixForNameRequest);
impl ::buffa::MessageName for CodecMulticodecPrefixForNameRequest {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecMulticodecPrefixForNameRequest";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecMulticodecPrefixForNameRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecMulticodecPrefixForNameRequest";
}
impl ::buffa::Message for CodecMulticodecPrefixForNameRequest {
    /// 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.name.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.name) 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.name.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.name, 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, 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();
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecMulticodecPrefixForNameRequest {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecMulticodecPrefixForNameRequest";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecMulticodecPrefixForNameRequest {
    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)]
pub const __CODEC_MULTICODEC_PREFIX_FOR_NAME_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecMulticodecPrefixForNameRequest",
    to_json: ::buffa::type_registry::any_to_json::<CodecMulticodecPrefixForNameRequest>,
    from_json: ::buffa::type_registry::any_from_json::<
        CodecMulticodecPrefixForNameRequest,
    >,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecMulticodecLookupPrefixRequest {
    /// Field 1: `value`
    #[serde(
        rename = "value",
        serialize_with = "__reallyme_serialize_sensitive_bytes",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_bytes"
    )]
    pub value: ::buffa::alloc::vec::Vec<u8>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecMulticodecLookupPrefixRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecMulticodecLookupPrefixRequest")
            .field("value", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecMulticodecLookupPrefixRequest {
    fn drop(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecMulticodecLookupPrefixRequest {}
impl<'de> ::serde::Deserialize<'de> for CodecMulticodecLookupPrefixRequest {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "value", deserialize_with = "deserialize_zeroizing_bytes")]
            value: ::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            value: ::core::mem::take(&mut *wire.value),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecMulticodecLookupPrefixRequest {
    /// 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/reallyme.codec.v1.CodecMulticodecLookupPrefixRequest";
}
::buffa::impl_default_instance!(CodecMulticodecLookupPrefixRequest);
impl ::buffa::MessageName for CodecMulticodecLookupPrefixRequest {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecMulticodecLookupPrefixRequest";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecMulticodecLookupPrefixRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecMulticodecLookupPrefixRequest";
}
impl ::buffa::Message for CodecMulticodecLookupPrefixRequest {
    /// 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.value.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.value) 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.value.is_empty() {
            ::buffa::types::put_shared_bytes_field(1u32, &self.value, 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,
                )?;
                ::zeroize::Zeroize::zeroize(&mut self.value);
                ::buffa::types::merge_bytes(&mut self.value, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecMulticodecLookupPrefixRequest {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecMulticodecLookupPrefixRequest";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecMulticodecLookupPrefixRequest {
    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)]
pub const __CODEC_MULTICODEC_LOOKUP_PREFIX_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecMulticodecLookupPrefixRequest",
    to_json: ::buffa::type_registry::any_to_json::<CodecMulticodecLookupPrefixRequest>,
    from_json: ::buffa::type_registry::any_from_json::<
        CodecMulticodecLookupPrefixRequest,
    >,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecMulticodecTableRequest {
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecMulticodecTableRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecMulticodecTableRequest").finish()
    }
}
impl CodecMulticodecTableRequest {
    /// 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/reallyme.codec.v1.CodecMulticodecTableRequest";
}
::buffa::impl_default_instance!(CodecMulticodecTableRequest);
impl ::buffa::MessageName for CodecMulticodecTableRequest {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecMulticodecTableRequest";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecMulticodecTableRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecMulticodecTableRequest";
}
impl ::buffa::Message for CodecMulticodecTableRequest {
    /// 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) {
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecMulticodecTableRequest {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecMulticodecTableRequest";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecMulticodecTableRequest {
    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)]
pub const __CODEC_MULTICODEC_TABLE_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecMulticodecTableRequest",
    to_json: ::buffa::type_registry::any_to_json::<CodecMulticodecTableRequest>,
    from_json: ::buffa::type_registry::any_from_json::<CodecMulticodecTableRequest>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecMultikeyParseRequest {
    /// Field 1: `multikey`
    #[serde(
        rename = "multikey",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub multikey: ::buffa::alloc::string::String,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecMultikeyParseRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecMultikeyParseRequest")
            .field("multikey", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecMultikeyParseRequest {
    fn drop(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.multikey);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecMultikeyParseRequest {}
impl<'de> ::serde::Deserialize<'de> for CodecMultikeyParseRequest {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "multikey", deserialize_with = "deserialize_zeroizing_string")]
            multikey: ::zeroize::Zeroizing<::buffa::alloc::string::String>,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            multikey: ::core::mem::take(&mut *wire.multikey),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecMultikeyParseRequest {
    /// 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/reallyme.codec.v1.CodecMultikeyParseRequest";
}
::buffa::impl_default_instance!(CodecMultikeyParseRequest);
impl ::buffa::MessageName for CodecMultikeyParseRequest {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecMultikeyParseRequest";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecMultikeyParseRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecMultikeyParseRequest";
}
impl ::buffa::Message for CodecMultikeyParseRequest {
    /// 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.multikey.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.multikey) 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.multikey.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.multikey, 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,
                )?;
                ::zeroize::Zeroize::zeroize(&mut self.multikey);
                ::buffa::types::merge_string(&mut self.multikey, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.multikey);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecMultikeyParseRequest {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecMultikeyParseRequest";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecMultikeyParseRequest {
    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)]
pub const __CODEC_MULTIKEY_PARSE_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecMultikeyParseRequest",
    to_json: ::buffa::type_registry::any_to_json::<CodecMultikeyParseRequest>,
    from_json: ::buffa::type_registry::any_from_json::<CodecMultikeyParseRequest>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDagCborVerifyCidRequest {
    /// Field 1: `cid`
    #[serde(
        rename = "cid",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub cid: ::buffa::alloc::string::String,
    /// Field 2: `payload`
    #[serde(
        rename = "payload",
        serialize_with = "__reallyme_serialize_sensitive_bytes",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_bytes"
    )]
    pub payload: ::buffa::alloc::vec::Vec<u8>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDagCborVerifyCidRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDagCborVerifyCidRequest")
            .field("cid", &self.cid)
            .field("payload", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDagCborVerifyCidRequest {
    fn drop(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.payload);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDagCborVerifyCidRequest {}
impl<'de> ::serde::Deserialize<'de> for CodecDagCborVerifyCidRequest {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "cid")]
            cid: ::buffa::alloc::string::String,
            #[serde(rename = "payload", deserialize_with = "deserialize_zeroizing_bytes")]
            payload: ::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            cid: ::core::mem::take(&mut wire.cid),
            payload: ::core::mem::take(&mut *wire.payload),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecDagCborVerifyCidRequest {
    /// 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/reallyme.codec.v1.CodecDagCborVerifyCidRequest";
}
::buffa::impl_default_instance!(CodecDagCborVerifyCidRequest);
impl ::buffa::MessageName for CodecDagCborVerifyCidRequest {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDagCborVerifyCidRequest";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDagCborVerifyCidRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDagCborVerifyCidRequest";
}
impl ::buffa::Message for CodecDagCborVerifyCidRequest {
    /// 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.cid.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.cid) as u64;
        }
        if !self.payload.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.payload) 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.cid.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.cid, buf);
        }
        if !self.payload.is_empty() {
            ::buffa::types::put_shared_bytes_field(2u32, &self.payload, 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.cid, buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::zeroize::Zeroize::zeroize(&mut self.payload);
                ::buffa::types::merge_bytes(&mut self.payload, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.cid.clear();
        ::zeroize::Zeroize::zeroize(&mut self.payload);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDagCborVerifyCidRequest {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDagCborVerifyCidRequest";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDagCborVerifyCidRequest {
    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)]
pub const __CODEC_DAG_CBOR_VERIFY_CID_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDagCborVerifyCidRequest",
    to_json: ::buffa::type_registry::any_to_json::<CodecDagCborVerifyCidRequest>,
    from_json: ::buffa::type_registry::any_from_json::<CodecDagCborVerifyCidRequest>,
    is_wkt: false,
};
/// CodecDagCborEncodeRequest is the typed recursive DAG-CBOR encode contract.
/// DAG-CBOR map keys are restricted to text keys by
/// the adapter even though the reusable recursive value schema can represent
/// the wider deterministic-CBOR key domain.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDagCborEncodeRequest {
    /// Field 1: `value`
    #[serde(
        rename = "value",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub value: ::buffa::MessageField<
        CodecDeterministicCborValue,
        ::buffa::Inline<CodecDeterministicCborValue>,
    >,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDagCborEncodeRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDagCborEncodeRequest").field("value", &"<redacted>").finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDagCborEncodeRequest {
    fn drop(&mut self) {
        __reallyme_zeroize_message_field(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDagCborEncodeRequest {}
impl<'de> ::serde::Deserialize<'de> for CodecDagCborEncodeRequest {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "value")]
            value: ::buffa::MessageField<
        CodecDeterministicCborValue,
        ::buffa::Inline<CodecDeterministicCborValue>,
    >,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            value: ::core::mem::take(&mut wire.value),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecDagCborEncodeRequest {
    /// 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/reallyme.codec.v1.CodecDagCborEncodeRequest";
}
::buffa::impl_default_instance!(CodecDagCborEncodeRequest);
impl ::buffa::MessageName for CodecDagCborEncodeRequest {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDagCborEncodeRequest";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDagCborEncodeRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDagCborEncodeRequest";
}
impl ::buffa::Message for CodecDagCborEncodeRequest {
    /// 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.value.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.value.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 self.value.is_set() {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.value.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.value.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) {
        __reallyme_zeroize_message_field(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDagCborEncodeRequest {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDagCborEncodeRequest";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDagCborEncodeRequest {
    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)]
pub const __CODEC_DAG_CBOR_ENCODE_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDagCborEncodeRequest",
    to_json: ::buffa::type_registry::any_to_json::<CodecDagCborEncodeRequest>,
    from_json: ::buffa::type_registry::any_from_json::<CodecDagCborEncodeRequest>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDagCborEncodeResult {
    /// Encoded DAG-CBOR bytes may contain the complete sensitive document.
    ///
    /// Field 1: `encoded`
    #[serde(
        rename = "encoded",
        serialize_with = "__reallyme_serialize_sensitive_bytes",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_bytes"
    )]
    pub encoded: ::buffa::alloc::vec::Vec<u8>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDagCborEncodeResult {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDagCborEncodeResult")
            .field("encoded", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDagCborEncodeResult {
    fn drop(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.encoded);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDagCborEncodeResult {}
impl<'de> ::serde::Deserialize<'de> for CodecDagCborEncodeResult {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "encoded", deserialize_with = "deserialize_zeroizing_bytes")]
            encoded: ::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            encoded: ::core::mem::take(&mut *wire.encoded),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecDagCborEncodeResult {
    /// 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/reallyme.codec.v1.CodecDagCborEncodeResult";
}
::buffa::impl_default_instance!(CodecDagCborEncodeResult);
impl ::buffa::MessageName for CodecDagCborEncodeResult {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDagCborEncodeResult";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDagCborEncodeResult";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDagCborEncodeResult";
}
impl ::buffa::Message for CodecDagCborEncodeResult {
    /// 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.encoded.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.encoded) 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.encoded.is_empty() {
            ::buffa::types::put_shared_bytes_field(1u32, &self.encoded, 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,
                )?;
                ::zeroize::Zeroize::zeroize(&mut self.encoded);
                ::buffa::types::merge_bytes(&mut self.encoded, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.encoded);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDagCborEncodeResult {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDagCborEncodeResult";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDagCborEncodeResult {
    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)]
pub const __CODEC_DAG_CBOR_ENCODE_RESULT_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDagCborEncodeResult",
    to_json: ::buffa::type_registry::any_to_json::<CodecDagCborEncodeResult>,
    from_json: ::buffa::type_registry::any_from_json::<CodecDagCborEncodeResult>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDagCborDecodeRequest {
    /// Encoded DAG-CBOR bytes may contain the complete sensitive document.
    ///
    /// Field 1: `encoded`
    #[serde(
        rename = "encoded",
        serialize_with = "__reallyme_serialize_sensitive_bytes",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_bytes"
    )]
    pub encoded: ::buffa::alloc::vec::Vec<u8>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDagCborDecodeRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDagCborDecodeRequest")
            .field("encoded", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDagCborDecodeRequest {
    fn drop(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.encoded);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDagCborDecodeRequest {}
impl<'de> ::serde::Deserialize<'de> for CodecDagCborDecodeRequest {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "encoded", deserialize_with = "deserialize_zeroizing_bytes")]
            encoded: ::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            encoded: ::core::mem::take(&mut *wire.encoded),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecDagCborDecodeRequest {
    /// 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/reallyme.codec.v1.CodecDagCborDecodeRequest";
}
::buffa::impl_default_instance!(CodecDagCborDecodeRequest);
impl ::buffa::MessageName for CodecDagCborDecodeRequest {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDagCborDecodeRequest";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDagCborDecodeRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDagCborDecodeRequest";
}
impl ::buffa::Message for CodecDagCborDecodeRequest {
    /// 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.encoded.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.encoded) 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.encoded.is_empty() {
            ::buffa::types::put_shared_bytes_field(1u32, &self.encoded, 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,
                )?;
                ::zeroize::Zeroize::zeroize(&mut self.encoded);
                ::buffa::types::merge_bytes(&mut self.encoded, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.encoded);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDagCborDecodeRequest {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDagCborDecodeRequest";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDagCborDecodeRequest {
    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)]
pub const __CODEC_DAG_CBOR_DECODE_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDagCborDecodeRequest",
    to_json: ::buffa::type_registry::any_to_json::<CodecDagCborDecodeRequest>,
    from_json: ::buffa::type_registry::any_from_json::<CodecDagCborDecodeRequest>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDagCborDecodeResult {
    /// Field 1: `value`
    #[serde(
        rename = "value",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub value: ::buffa::MessageField<
        CodecDeterministicCborValue,
        ::buffa::Inline<CodecDeterministicCborValue>,
    >,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDagCborDecodeResult {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDagCborDecodeResult").field("value", &"<redacted>").finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDagCborDecodeResult {
    fn drop(&mut self) {
        __reallyme_zeroize_message_field(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDagCborDecodeResult {}
impl<'de> ::serde::Deserialize<'de> for CodecDagCborDecodeResult {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "value")]
            value: ::buffa::MessageField<
        CodecDeterministicCborValue,
        ::buffa::Inline<CodecDeterministicCborValue>,
    >,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            value: ::core::mem::take(&mut wire.value),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecDagCborDecodeResult {
    /// 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/reallyme.codec.v1.CodecDagCborDecodeResult";
}
::buffa::impl_default_instance!(CodecDagCborDecodeResult);
impl ::buffa::MessageName for CodecDagCborDecodeResult {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDagCborDecodeResult";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDagCborDecodeResult";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDagCborDecodeResult";
}
impl ::buffa::Message for CodecDagCborDecodeResult {
    /// 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.value.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.value.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 self.value.is_set() {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.value.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.value.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) {
        __reallyme_zeroize_message_field(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDagCborDecodeResult {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDagCborDecodeResult";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDagCborDecodeResult {
    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)]
pub const __CODEC_DAG_CBOR_DECODE_RESULT_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDagCborDecodeResult",
    to_json: ::buffa::type_registry::any_to_json::<CodecDagCborDecodeResult>,
    from_json: ::buffa::type_registry::any_from_json::<CodecDagCborDecodeResult>,
    is_wkt: false,
};
/// Zero limits select the documented codec defaults. An empty allowed-label list
/// selects PUBLIC KEY only; private-key labels require an explicit allowlist.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecPemDecodeOptions {
    /// Field 1: `allowed_labels`
    #[serde(
        rename = "allowedLabels",
        alias = "allowed_labels",
        with = "::buffa::json_helpers::repeated_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub allowed_labels: ::buffa::alloc::vec::Vec<::buffa::EnumValue<CodecPemLabel>>,
    /// Field 2: `max_input_len`
    #[serde(
        rename = "maxInputLen",
        alias = "max_input_len",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub max_input_len: u32,
    /// Field 3: `max_der_len`
    #[serde(
        rename = "maxDerLen",
        alias = "max_der_len",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub max_der_len: u32,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecPemDecodeOptions {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecPemDecodeOptions")
            .field("allowed_labels", &self.allowed_labels)
            .field("max_input_len", &self.max_input_len)
            .field("max_der_len", &self.max_der_len)
            .finish()
    }
}
impl CodecPemDecodeOptions {
    /// 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/reallyme.codec.v1.CodecPemDecodeOptions";
}
::buffa::impl_default_instance!(CodecPemDecodeOptions);
impl ::buffa::MessageName for CodecPemDecodeOptions {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecPemDecodeOptions";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecPemDecodeOptions";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecPemDecodeOptions";
}
impl ::buffa::Message for CodecPemDecodeOptions {
    /// 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.allowed_labels.is_empty() {
            let payload: u64 = self
                .allowed_labels
                .iter()
                .map(|v| ::buffa::types::int32_encoded_len(v.to_i32()) as u64)
                .sum::<u64>();
            size += 1u64 + ::buffa::encoding::varint_len(payload) as u64 + payload;
        }
        if self.max_input_len != 0u32 {
            size += 1u64 + ::buffa::types::uint32_encoded_len(self.max_input_len) as u64;
        }
        if self.max_der_len != 0u32 {
            size += 1u64 + ::buffa::types::uint32_encoded_len(self.max_der_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 !self.allowed_labels.is_empty() {
            let payload: u64 = self
                .allowed_labels
                .iter()
                .map(|v| ::buffa::types::int32_encoded_len(v.to_i32()) as u64)
                .sum::<u64>();
            ::buffa::types::put_len_delimited_header(1u32, payload, buf);
            for v in &self.allowed_labels {
                ::buffa::types::encode_int32(v.to_i32(), buf);
            }
        }
        if self.max_input_len != 0u32 {
            ::buffa::types::put_uint32_field(2u32, self.max_input_len, buf);
        }
        if self.max_der_len != 0u32 {
            ::buffa::types::put_uint32_field(3u32, self.max_der_len, 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,
                        );
                    }
                    self.allowed_labels.reserve(len);
                    let mut limited = buf.take(len);
                    while limited.has_remaining() {
                        self.allowed_labels
                            .push(
                                ::buffa::EnumValue::from(
                                    ::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.allowed_labels
                        .push(
                            ::buffa::EnumValue::from(::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::Varint,
                )?;
                self.max_input_len = ::buffa::types::decode_uint32(buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.max_der_len = ::buffa::types::decode_uint32(buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.allowed_labels.clear();
        self.max_input_len = 0u32;
        self.max_der_len = 0u32;
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecPemDecodeOptions {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecPemDecodeOptions";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecPemDecodeOptions {
    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)]
pub const __CODEC_PEM_DECODE_OPTIONS_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecPemDecodeOptions",
    to_json: ::buffa::type_registry::any_to_json::<CodecPemDecodeOptions>,
    from_json: ::buffa::type_registry::any_from_json::<CodecPemDecodeOptions>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecPemDecodeRequest {
    /// PEM may contain private-key material. Bytes avoid long-lived immutable
    /// managed strings and let generated hardening wipe the owned request field.
    ///
    /// Field 1: `pem`
    #[serde(
        rename = "pem",
        serialize_with = "__reallyme_serialize_sensitive_bytes",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_bytes"
    )]
    pub pem: ::buffa::alloc::vec::Vec<u8>,
    /// Field 2: `options`
    #[serde(
        rename = "options",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub options: ::buffa::MessageField<
        CodecPemDecodeOptions,
        ::buffa::Inline<CodecPemDecodeOptions>,
    >,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecPemDecodeRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecPemDecodeRequest")
            .field("pem", &"<redacted>")
            .field("options", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecPemDecodeRequest {
    fn drop(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.pem);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecPemDecodeRequest {}
impl<'de> ::serde::Deserialize<'de> for CodecPemDecodeRequest {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "pem", deserialize_with = "deserialize_zeroizing_bytes")]
            pem: ::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>,
            #[serde(rename = "options")]
            options: ::buffa::MessageField<
        CodecPemDecodeOptions,
        ::buffa::Inline<CodecPemDecodeOptions>,
    >,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            pem: ::core::mem::take(&mut *wire.pem),
            options: ::core::mem::take(&mut wire.options),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecPemDecodeRequest {
    /// 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/reallyme.codec.v1.CodecPemDecodeRequest";
}
::buffa::impl_default_instance!(CodecPemDecodeRequest);
impl ::buffa::MessageName for CodecPemDecodeRequest {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecPemDecodeRequest";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecPemDecodeRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecPemDecodeRequest";
}
impl ::buffa::Message for CodecPemDecodeRequest {
    /// 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.pem.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.pem) 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 !self.pem.is_empty() {
            ::buffa::types::put_shared_bytes_field(1u32, &self.pem, 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,
                )?;
                ::zeroize::Zeroize::zeroize(&mut self.pem);
                ::buffa::types::merge_bytes(&mut self.pem, 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) {
        ::zeroize::Zeroize::zeroize(&mut self.pem);
        self.options = ::buffa::MessageField::none();
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecPemDecodeRequest {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecPemDecodeRequest";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecPemDecodeRequest {
    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)]
pub const __CODEC_PEM_DECODE_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecPemDecodeRequest",
    to_json: ::buffa::type_registry::any_to_json::<CodecPemDecodeRequest>,
    from_json: ::buffa::type_registry::any_from_json::<CodecPemDecodeRequest>,
    is_wkt: false,
};
/// Zero values select the documented codec defaults.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecPemEncodeOptions {
    /// Field 1: `max_der_len`
    #[serde(
        rename = "maxDerLen",
        alias = "max_der_len",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub max_der_len: u32,
    /// Field 2: `line_width`
    #[serde(
        rename = "lineWidth",
        alias = "line_width",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub line_width: u32,
    /// Field 3: `line_ending`
    #[serde(
        rename = "lineEnding",
        alias = "line_ending",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub line_ending: ::buffa::EnumValue<CodecPemLineEnding>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecPemEncodeOptions {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecPemEncodeOptions")
            .field("max_der_len", &self.max_der_len)
            .field("line_width", &self.line_width)
            .field("line_ending", &self.line_ending)
            .finish()
    }
}
impl CodecPemEncodeOptions {
    /// 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/reallyme.codec.v1.CodecPemEncodeOptions";
}
::buffa::impl_default_instance!(CodecPemEncodeOptions);
impl ::buffa::MessageName for CodecPemEncodeOptions {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecPemEncodeOptions";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecPemEncodeOptions";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecPemEncodeOptions";
}
impl ::buffa::Message for CodecPemEncodeOptions {
    /// 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.max_der_len != 0u32 {
            size += 1u64 + ::buffa::types::uint32_encoded_len(self.max_der_len) as u64;
        }
        if self.line_width != 0u32 {
            size += 1u64 + ::buffa::types::uint32_encoded_len(self.line_width) as u64;
        }
        {
            let val = self.line_ending.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) 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.max_der_len != 0u32 {
            ::buffa::types::put_uint32_field(1u32, self.max_der_len, buf);
        }
        if self.line_width != 0u32 {
            ::buffa::types::put_uint32_field(2u32, self.line_width, buf);
        }
        {
            let val = self.line_ending.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(3u32, val, 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.max_der_len = ::buffa::types::decode_uint32(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.line_width = ::buffa::types::decode_uint32(buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.line_ending = ::buffa::EnumValue::from(
                    ::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.max_der_len = 0u32;
        self.line_width = 0u32;
        self.line_ending = ::buffa::EnumValue::from(0);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecPemEncodeOptions {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecPemEncodeOptions";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecPemEncodeOptions {
    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)]
pub const __CODEC_PEM_ENCODE_OPTIONS_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecPemEncodeOptions",
    to_json: ::buffa::type_registry::any_to_json::<CodecPemEncodeOptions>,
    from_json: ::buffa::type_registry::any_from_json::<CodecPemEncodeOptions>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecPemEncodeRequest {
    /// Field 1: `label`
    #[serde(
        rename = "label",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub label: ::buffa::EnumValue<CodecPemLabel>,
    /// DER may contain private-key material. Generated owned-message drop wipes
    /// the retained field; transport decoders may create temporary copies that
    /// cannot be reliably wiped. Use binary requests for secret-bearing DER.
    ///
    /// Field 2: `der`
    #[serde(
        rename = "der",
        serialize_with = "__reallyme_serialize_sensitive_bytes",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_bytes"
    )]
    pub der: ::buffa::alloc::vec::Vec<u8>,
    /// Field 3: `options`
    #[serde(
        rename = "options",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub options: ::buffa::MessageField<
        CodecPemEncodeOptions,
        ::buffa::Inline<CodecPemEncodeOptions>,
    >,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecPemEncodeRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecPemEncodeRequest")
            .field("label", &"<redacted>")
            .field("der", &"<redacted>")
            .field("options", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecPemEncodeRequest {
    fn drop(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.der);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecPemEncodeRequest {}
impl<'de> ::serde::Deserialize<'de> for CodecPemEncodeRequest {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "label", with = "::buffa::json_helpers::proto_enum")]
            label: ::buffa::EnumValue<CodecPemLabel>,
            #[serde(rename = "der", deserialize_with = "deserialize_zeroizing_bytes")]
            der: ::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>,
            #[serde(rename = "options")]
            options: ::buffa::MessageField<
        CodecPemEncodeOptions,
        ::buffa::Inline<CodecPemEncodeOptions>,
    >,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            label: ::core::mem::take(&mut wire.label),
            der: ::core::mem::take(&mut *wire.der),
            options: ::core::mem::take(&mut wire.options),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecPemEncodeRequest {
    /// 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/reallyme.codec.v1.CodecPemEncodeRequest";
}
::buffa::impl_default_instance!(CodecPemEncodeRequest);
impl ::buffa::MessageName for CodecPemEncodeRequest {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecPemEncodeRequest";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecPemEncodeRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecPemEncodeRequest";
}
impl ::buffa::Message for CodecPemEncodeRequest {
    /// 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;
        {
            let val = self.label.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) as u64;
            }
        }
        if !self.der.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.der) 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 _;
        {
            let val = self.label.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, buf);
            }
        }
        if !self.der.is_empty() {
            ::buffa::types::put_shared_bytes_field(2u32, &self.der, 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.label = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::zeroize::Zeroize::zeroize(&mut self.der);
                ::buffa::types::merge_bytes(&mut self.der, 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.label = ::buffa::EnumValue::from(0);
        ::zeroize::Zeroize::zeroize(&mut self.der);
        self.options = ::buffa::MessageField::none();
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecPemEncodeRequest {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecPemEncodeRequest";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecPemEncodeRequest {
    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)]
pub const __CODEC_PEM_ENCODE_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecPemEncodeRequest",
    to_json: ::buffa::type_registry::any_to_json::<CodecPemEncodeRequest>,
    from_json: ::buffa::type_registry::any_from_json::<CodecPemEncodeRequest>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecPemEncodeResult {
    /// PEM armor may contain private-key material and remains byte-oriented so
    /// SDK callers can promptly wipe the returned owner.
    ///
    /// Field 1: `pem`
    #[serde(
        rename = "pem",
        serialize_with = "__reallyme_serialize_sensitive_bytes",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_bytes"
    )]
    pub pem: ::buffa::alloc::vec::Vec<u8>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecPemEncodeResult {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecPemEncodeResult").field("pem", &"<redacted>").finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecPemEncodeResult {
    fn drop(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.pem);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecPemEncodeResult {}
impl<'de> ::serde::Deserialize<'de> for CodecPemEncodeResult {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "pem", deserialize_with = "deserialize_zeroizing_bytes")]
            pem: ::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            pem: ::core::mem::take(&mut *wire.pem),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecPemEncodeResult {
    /// 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/reallyme.codec.v1.CodecPemEncodeResult";
}
::buffa::impl_default_instance!(CodecPemEncodeResult);
impl ::buffa::MessageName for CodecPemEncodeResult {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecPemEncodeResult";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecPemEncodeResult";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecPemEncodeResult";
}
impl ::buffa::Message for CodecPemEncodeResult {
    /// 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.pem.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.pem) 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.pem.is_empty() {
            ::buffa::types::put_shared_bytes_field(1u32, &self.pem, 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,
                )?;
                ::zeroize::Zeroize::zeroize(&mut self.pem);
                ::buffa::types::merge_bytes(&mut self.pem, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.pem);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecPemEncodeResult {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecPemEncodeResult";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecPemEncodeResult {
    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)]
pub const __CODEC_PEM_ENCODE_RESULT_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecPemEncodeResult",
    to_json: ::buffa::type_registry::any_to_json::<CodecPemEncodeResult>,
    from_json: ::buffa::type_registry::any_from_json::<CodecPemEncodeResult>,
    is_wkt: false,
};
/// CodecDeterministicCborNull is the explicit null branch for the deterministic
/// generic-CBOR value union.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDeterministicCborNull {
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDeterministicCborNull {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborNull").finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDeterministicCborNull {
    fn drop(&mut self) {
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDeterministicCborNull {}
impl<'de> ::serde::Deserialize<'de> for CodecDeterministicCborNull {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {

        }

        let _wire = Wire::deserialize(deserializer)?;
        Ok(Self {

            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecDeterministicCborNull {
    /// 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/reallyme.codec.v1.CodecDeterministicCborNull";
}
::buffa::impl_default_instance!(CodecDeterministicCborNull);
impl ::buffa::MessageName for CodecDeterministicCborNull {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborNull";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborNull";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborNull";
}
impl ::buffa::Message for CodecDeterministicCborNull {
    /// 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) {
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDeterministicCborNull {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDeterministicCborNull";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDeterministicCborNull {
    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)]
pub const __CODEC_DETERMINISTIC_CBOR_NULL_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborNull",
    to_json: ::buffa::type_registry::any_to_json::<CodecDeterministicCborNull>,
    from_json: ::buffa::type_registry::any_from_json::<CodecDeterministicCborNull>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDeterministicCborBool {
    /// Field 1: `value`
    #[serde(
        rename = "value",
        with = "::buffa::json_helpers::proto_bool",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
    )]
    pub value: bool,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDeterministicCborBool {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborBool").field("value", &"<redacted>").finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDeterministicCborBool {
    fn drop(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDeterministicCborBool {}
impl<'de> ::serde::Deserialize<'de> for CodecDeterministicCborBool {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "value")]
            value: bool,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            value: ::core::mem::take(&mut wire.value),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecDeterministicCborBool {
    /// 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/reallyme.codec.v1.CodecDeterministicCborBool";
}
::buffa::impl_default_instance!(CodecDeterministicCborBool);
impl ::buffa::MessageName for CodecDeterministicCborBool {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborBool";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborBool";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborBool";
}
impl ::buffa::Message for CodecDeterministicCborBool {
    /// 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.value {
            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 self.value {
            ::buffa::types::put_bool_field(1u32, self.value, 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.value = ::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) {
        ::zeroize::Zeroize::zeroize(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDeterministicCborBool {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDeterministicCborBool";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDeterministicCborBool {
    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)]
pub const __CODEC_DETERMINISTIC_CBOR_BOOL_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborBool",
    to_json: ::buffa::type_registry::any_to_json::<CodecDeterministicCborBool>,
    from_json: ::buffa::type_registry::any_from_json::<CodecDeterministicCborBool>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDeterministicCborUnsignedInteger {
    /// Field 1: `value`
    #[serde(
        rename = "value",
        with = "::buffa::json_helpers::uint64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u64"
    )]
    pub value: u64,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDeterministicCborUnsignedInteger {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborUnsignedInteger")
            .field("value", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDeterministicCborUnsignedInteger {
    fn drop(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDeterministicCborUnsignedInteger {}
impl<'de> ::serde::Deserialize<'de> for CodecDeterministicCborUnsignedInteger {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "value", with = "::buffa::json_helpers::uint64")]
            value: u64,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            value: ::core::mem::take(&mut wire.value),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecDeterministicCborUnsignedInteger {
    /// 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/reallyme.codec.v1.CodecDeterministicCborUnsignedInteger";
}
::buffa::impl_default_instance!(CodecDeterministicCborUnsignedInteger);
impl ::buffa::MessageName for CodecDeterministicCborUnsignedInteger {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborUnsignedInteger";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborUnsignedInteger";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborUnsignedInteger";
}
impl ::buffa::Message for CodecDeterministicCborUnsignedInteger {
    /// 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.value != 0u64 {
            size += 1u64 + ::buffa::types::uint64_encoded_len(self.value) 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.value != 0u64 {
            ::buffa::types::put_uint64_field(1u32, self.value, 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.value = ::buffa::types::decode_uint64(buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDeterministicCborUnsignedInteger {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDeterministicCborUnsignedInteger";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDeterministicCborUnsignedInteger {
    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)]
pub const __CODEC_DETERMINISTIC_CBOR_UNSIGNED_INTEGER_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborUnsignedInteger",
    to_json: ::buffa::type_registry::any_to_json::<
        CodecDeterministicCborUnsignedInteger,
    >,
    from_json: ::buffa::type_registry::any_from_json::<
        CodecDeterministicCborUnsignedInteger,
    >,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDeterministicCborNegativeInteger {
    /// Field 1: `value`
    #[serde(
        rename = "value",
        with = "::buffa::json_helpers::int64",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i64"
    )]
    pub value: i64,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDeterministicCborNegativeInteger {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborNegativeInteger")
            .field("value", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDeterministicCborNegativeInteger {
    fn drop(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDeterministicCborNegativeInteger {}
impl<'de> ::serde::Deserialize<'de> for CodecDeterministicCborNegativeInteger {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "value", with = "::buffa::json_helpers::int64")]
            value: i64,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            value: ::core::mem::take(&mut wire.value),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecDeterministicCborNegativeInteger {
    /// 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/reallyme.codec.v1.CodecDeterministicCborNegativeInteger";
}
::buffa::impl_default_instance!(CodecDeterministicCborNegativeInteger);
impl ::buffa::MessageName for CodecDeterministicCborNegativeInteger {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborNegativeInteger";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborNegativeInteger";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborNegativeInteger";
}
impl ::buffa::Message for CodecDeterministicCborNegativeInteger {
    /// 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.value != 0i64 {
            size += 1u64 + ::buffa::types::sint64_encoded_len(self.value) 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.value != 0i64 {
            ::buffa::types::put_sint64_field(1u32, self.value, 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.value = ::buffa::types::decode_sint64(buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDeterministicCborNegativeInteger {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDeterministicCborNegativeInteger";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDeterministicCborNegativeInteger {
    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)]
pub const __CODEC_DETERMINISTIC_CBOR_NEGATIVE_INTEGER_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborNegativeInteger",
    to_json: ::buffa::type_registry::any_to_json::<
        CodecDeterministicCborNegativeInteger,
    >,
    from_json: ::buffa::type_registry::any_from_json::<
        CodecDeterministicCborNegativeInteger,
    >,
    is_wkt: false,
};
/// CodecDeterministicCborInteger is the exact integer representation supported
/// by deterministic generic CBOR. Negative values are restricted to
/// i64::MIN..=-1; zero and positive values must use unsigned_value.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDeterministicCborInteger {
    #[serde(flatten)]
    pub value: ::core::option::Option<
        __buffa::oneof::codec_deterministic_cbor_integer::Value,
    >,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDeterministicCborInteger {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborInteger")
            .field("value", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDeterministicCborInteger {
    fn drop(&mut self) {
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDeterministicCborInteger {}
impl CodecDeterministicCborInteger {
    /// 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/reallyme.codec.v1.CodecDeterministicCborInteger";
}
::buffa::impl_default_instance!(CodecDeterministicCborInteger);
impl ::buffa::MessageName for CodecDeterministicCborInteger {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborInteger";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborInteger";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborInteger";
}
impl ::buffa::Message for CodecDeterministicCborInteger {
    /// 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 ::core::option::Option::Some(ref v) = self.value {
            match v {
                __buffa::oneof::codec_deterministic_cbor_integer::Value::UnsignedValue(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_deterministic_cbor_integer::Value::NegativeValue(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner 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 ::core::option::Option::Some(ref v) = self.value {
            match v {
                __buffa::oneof::codec_deterministic_cbor_integer::Value::UnsignedValue(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_deterministic_cbor_integer::Value::NegativeValue(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        2u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.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,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_deterministic_cbor_integer::Value::UnsignedValue(
                        ref mut existing,
                    ),
                ) = self.value
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.value = ::core::option::Option::Some(
                        __buffa::oneof::codec_deterministic_cbor_integer::Value::UnsignedValue(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_deterministic_cbor_integer::Value::NegativeValue(
                        ref mut existing,
                    ),
                ) = self.value
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.value = ::core::option::Option::Some(
                        __buffa::oneof::codec_deterministic_cbor_integer::Value::NegativeValue(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            _ => {
                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;
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDeterministicCborInteger {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDeterministicCborInteger";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl<'de> ::serde::Deserialize<'de> for CodecDeterministicCborInteger {
    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 = CodecDeterministicCborInteger;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str("struct CodecDeterministicCborInteger")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: ::serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<CodecDeterministicCborInteger, A::Error> {
                let mut __oneof_value: ::core::option::Option<
                    __buffa::oneof::codec_deterministic_cbor_integer::Value,
                > = None;
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "unsignedValue" | "unsigned_value" => {
                            let v: ::core::option::Option<
                                CodecDeterministicCborUnsignedInteger,
                            > = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDeterministicCborUnsignedInteger,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_value.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'value'",
                                        ),
                                    );
                                }
                                __oneof_value = Some(
                                    __buffa::oneof::codec_deterministic_cbor_integer::Value::UnsignedValue(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "negativeValue" | "negative_value" => {
                            let v: ::core::option::Option<
                                CodecDeterministicCborNegativeInteger,
                            > = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDeterministicCborNegativeInteger,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_value.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'value'",
                                        ),
                                    );
                                }
                                __oneof_value = Some(
                                    __buffa::oneof::codec_deterministic_cbor_integer::Value::NegativeValue(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        _ => {
                            return Err(::serde::de::Error::custom("unknown field"));
                        }
                    }
                }
                let mut __r = <CodecDeterministicCborInteger as ::core::default::Default>::default();
                __r.value = __oneof_value;
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDeterministicCborInteger {
    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)]
pub const __CODEC_DETERMINISTIC_CBOR_INTEGER_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborInteger",
    to_json: ::buffa::type_registry::any_to_json::<CodecDeterministicCborInteger>,
    from_json: ::buffa::type_registry::any_from_json::<CodecDeterministicCborInteger>,
    is_wkt: false,
};
pub mod codec_deterministic_cbor_integer {
    #[allow(unused_imports)]
    use super::*;
    #[doc(inline)]
    pub use super::__buffa::oneof::codec_deterministic_cbor_integer::Value;
    #[doc(inline)]
    pub use super::__buffa::view::oneof::codec_deterministic_cbor_integer::Value as ValueView;
}
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDeterministicCborText {
    /// Field 1: `value`
    #[serde(
        rename = "value",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub value: ::buffa::alloc::string::String,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDeterministicCborText {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborText").field("value", &"<redacted>").finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDeterministicCborText {
    fn drop(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDeterministicCborText {}
impl<'de> ::serde::Deserialize<'de> for CodecDeterministicCborText {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "value", deserialize_with = "deserialize_zeroizing_string")]
            value: ::zeroize::Zeroizing<::buffa::alloc::string::String>,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            value: ::core::mem::take(&mut *wire.value),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecDeterministicCborText {
    /// 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/reallyme.codec.v1.CodecDeterministicCborText";
}
::buffa::impl_default_instance!(CodecDeterministicCborText);
impl ::buffa::MessageName for CodecDeterministicCborText {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborText";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborText";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborText";
}
impl ::buffa::Message for CodecDeterministicCborText {
    /// 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.value.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.value) 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.value.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.value, 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,
                )?;
                ::zeroize::Zeroize::zeroize(&mut self.value);
                ::buffa::types::merge_string(&mut self.value, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDeterministicCborText {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDeterministicCborText";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDeterministicCborText {
    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)]
pub const __CODEC_DETERMINISTIC_CBOR_TEXT_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborText",
    to_json: ::buffa::type_registry::any_to_json::<CodecDeterministicCborText>,
    from_json: ::buffa::type_registry::any_from_json::<CodecDeterministicCborText>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDeterministicCborBytes {
    /// Field 1: `value`
    #[serde(
        rename = "value",
        serialize_with = "__reallyme_serialize_sensitive_bytes",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_bytes"
    )]
    pub value: ::buffa::alloc::vec::Vec<u8>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDeterministicCborBytes {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborBytes")
            .field("value", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDeterministicCborBytes {
    fn drop(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDeterministicCborBytes {}
impl<'de> ::serde::Deserialize<'de> for CodecDeterministicCborBytes {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "value", deserialize_with = "deserialize_zeroizing_bytes")]
            value: ::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            value: ::core::mem::take(&mut *wire.value),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecDeterministicCborBytes {
    /// 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/reallyme.codec.v1.CodecDeterministicCborBytes";
}
::buffa::impl_default_instance!(CodecDeterministicCborBytes);
impl ::buffa::MessageName for CodecDeterministicCborBytes {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborBytes";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborBytes";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborBytes";
}
impl ::buffa::Message for CodecDeterministicCborBytes {
    /// 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.value.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.value) 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.value.is_empty() {
            ::buffa::types::put_shared_bytes_field(1u32, &self.value, 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,
                )?;
                ::zeroize::Zeroize::zeroize(&mut self.value);
                ::buffa::types::merge_bytes(&mut self.value, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDeterministicCborBytes {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDeterministicCborBytes";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDeterministicCborBytes {
    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)]
pub const __CODEC_DETERMINISTIC_CBOR_BYTES_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborBytes",
    to_json: ::buffa::type_registry::any_to_json::<CodecDeterministicCborBytes>,
    from_json: ::buffa::type_registry::any_from_json::<CodecDeterministicCborBytes>,
    is_wkt: false,
};
/// CodecDeterministicCborMapKey is the closed map-key domain for deterministic
/// generic CBOR. Protobuf map\<\> is intentionally not used because it cannot
/// preserve mixed key types or duplicate entries for semantic rejection.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDeterministicCborMapKey {
    #[serde(flatten)]
    pub key: ::core::option::Option<
        __buffa::oneof::codec_deterministic_cbor_map_key::Key,
    >,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDeterministicCborMapKey {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborMapKey").field("key", &"<redacted>").finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDeterministicCborMapKey {
    fn drop(&mut self) {
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDeterministicCborMapKey {}
impl CodecDeterministicCborMapKey {
    /// 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/reallyme.codec.v1.CodecDeterministicCborMapKey";
}
::buffa::impl_default_instance!(CodecDeterministicCborMapKey);
impl ::buffa::MessageName for CodecDeterministicCborMapKey {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborMapKey";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborMapKey";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborMapKey";
}
impl ::buffa::Message for CodecDeterministicCborMapKey {
    /// 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 ::core::option::Option::Some(ref v) = self.key {
            match v {
                __buffa::oneof::codec_deterministic_cbor_map_key::Key::IntegerKey(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_deterministic_cbor_map_key::Key::TextKey(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner 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 ::core::option::Option::Some(ref v) = self.key {
            match v {
                __buffa::oneof::codec_deterministic_cbor_map_key::Key::IntegerKey(x) => {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_deterministic_cbor_map_key::Key::TextKey(x) => {
                    ::buffa::types::put_len_delimited_header(
                        2u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.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,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_deterministic_cbor_map_key::Key::IntegerKey(
                        ref mut existing,
                    ),
                ) = self.key
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.key = ::core::option::Option::Some(
                        __buffa::oneof::codec_deterministic_cbor_map_key::Key::IntegerKey(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_deterministic_cbor_map_key::Key::TextKey(
                        ref mut existing,
                    ),
                ) = self.key
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.key = ::core::option::Option::Some(
                        __buffa::oneof::codec_deterministic_cbor_map_key::Key::TextKey(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.key = ::core::option::Option::None;
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDeterministicCborMapKey {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDeterministicCborMapKey";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl<'de> ::serde::Deserialize<'de> for CodecDeterministicCborMapKey {
    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 = CodecDeterministicCborMapKey;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str("struct CodecDeterministicCborMapKey")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: ::serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<CodecDeterministicCborMapKey, A::Error> {
                let mut __oneof_key: ::core::option::Option<
                    __buffa::oneof::codec_deterministic_cbor_map_key::Key,
                > = None;
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "integerKey" | "integer_key" => {
                            let v: ::core::option::Option<
                                CodecDeterministicCborInteger,
                            > = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDeterministicCborInteger,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_key.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'key'",
                                        ),
                                    );
                                }
                                __oneof_key = Some(
                                    __buffa::oneof::codec_deterministic_cbor_map_key::Key::IntegerKey(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "textKey" | "text_key" => {
                            let v: ::core::option::Option<CodecDeterministicCborText> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDeterministicCborText,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_key.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'key'",
                                        ),
                                    );
                                }
                                __oneof_key = Some(
                                    __buffa::oneof::codec_deterministic_cbor_map_key::Key::TextKey(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        _ => {
                            return Err(::serde::de::Error::custom("unknown field"));
                        }
                    }
                }
                let mut __r = <CodecDeterministicCborMapKey as ::core::default::Default>::default();
                __r.key = __oneof_key;
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDeterministicCborMapKey {
    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)]
pub const __CODEC_DETERMINISTIC_CBOR_MAP_KEY_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborMapKey",
    to_json: ::buffa::type_registry::any_to_json::<CodecDeterministicCborMapKey>,
    from_json: ::buffa::type_registry::any_from_json::<CodecDeterministicCborMapKey>,
    is_wkt: false,
};
pub mod codec_deterministic_cbor_map_key {
    #[allow(unused_imports)]
    use super::*;
    #[doc(inline)]
    pub use super::__buffa::oneof::codec_deterministic_cbor_map_key::Key;
    #[doc(inline)]
    pub use super::__buffa::view::oneof::codec_deterministic_cbor_map_key::Key as KeyView;
}
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDeterministicCborMapEntry {
    /// Field 1: `key`
    #[serde(
        rename = "key",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub key: ::buffa::MessageField<
        CodecDeterministicCborMapKey,
        ::buffa::Inline<CodecDeterministicCborMapKey>,
    >,
    /// Field 2: `value`
    #[serde(
        rename = "value",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub value: ::buffa::MessageField<
        CodecDeterministicCborValue,
        ::buffa::Inline<CodecDeterministicCborValue>,
    >,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDeterministicCborMapEntry {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborMapEntry")
            .field("key", &"<redacted>")
            .field("value", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDeterministicCborMapEntry {
    fn drop(&mut self) {
        __reallyme_zeroize_message_field(&mut self.key);
        __reallyme_zeroize_message_field(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDeterministicCborMapEntry {}
impl<'de> ::serde::Deserialize<'de> for CodecDeterministicCborMapEntry {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "key")]
            key: ::buffa::MessageField<
        CodecDeterministicCborMapKey,
        ::buffa::Inline<CodecDeterministicCborMapKey>,
    >,
            #[serde(rename = "value")]
            value: ::buffa::MessageField<
        CodecDeterministicCborValue,
        ::buffa::Inline<CodecDeterministicCborValue>,
    >,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            key: ::core::mem::take(&mut wire.key),
            value: ::core::mem::take(&mut wire.value),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecDeterministicCborMapEntry {
    /// 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/reallyme.codec.v1.CodecDeterministicCborMapEntry";
}
::buffa::impl_default_instance!(CodecDeterministicCborMapEntry);
impl ::buffa::MessageName for CodecDeterministicCborMapEntry {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborMapEntry";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborMapEntry";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborMapEntry";
}
impl ::buffa::Message for CodecDeterministicCborMapEntry {
    /// 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.key.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.key.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.value.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.value.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 self.key.is_set() {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.key.write_to(__cache, buf);
        }
        if self.value.is_set() {
            ::buffa::types::put_len_delimited_header(
                2u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.value.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.key.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.value.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) {
        __reallyme_zeroize_message_field(&mut self.key);
        __reallyme_zeroize_message_field(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDeterministicCborMapEntry {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDeterministicCborMapEntry";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDeterministicCborMapEntry {
    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)]
pub const __CODEC_DETERMINISTIC_CBOR_MAP_ENTRY_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborMapEntry",
    to_json: ::buffa::type_registry::any_to_json::<CodecDeterministicCborMapEntry>,
    from_json: ::buffa::type_registry::any_from_json::<CodecDeterministicCborMapEntry>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDeterministicCborArray {
    /// Field 1: `values`
    #[serde(
        rename = "values",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub values: ::buffa::alloc::vec::Vec<CodecDeterministicCborValue>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDeterministicCborArray {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborArray")
            .field("values", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDeterministicCborArray {
    fn drop(&mut self) {
        __reallyme_zeroize_message_vec(&mut self.values);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDeterministicCborArray {}
impl<'de> ::serde::Deserialize<'de> for CodecDeterministicCborArray {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "values")]
            values: ::buffa::alloc::vec::Vec<CodecDeterministicCborValue>,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            values: ::core::mem::take(&mut wire.values),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecDeterministicCborArray {
    /// 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/reallyme.codec.v1.CodecDeterministicCborArray";
}
::buffa::impl_default_instance!(CodecDeterministicCborArray);
impl ::buffa::MessageName for CodecDeterministicCborArray {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborArray";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborArray";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborArray";
}
impl ::buffa::Message for CodecDeterministicCborArray {
    /// 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.values {
            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.values {
            ::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.values.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        __reallyme_zeroize_message_vec(&mut self.values);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDeterministicCborArray {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDeterministicCborArray";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDeterministicCborArray {
    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)]
pub const __CODEC_DETERMINISTIC_CBOR_ARRAY_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborArray",
    to_json: ::buffa::type_registry::any_to_json::<CodecDeterministicCborArray>,
    from_json: ::buffa::type_registry::any_from_json::<CodecDeterministicCborArray>,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDeterministicCborMap {
    /// Field 1: `entries`
    #[serde(
        rename = "entries",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub entries: ::buffa::alloc::vec::Vec<CodecDeterministicCborMapEntry>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDeterministicCborMap {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborMap")
            .field("entries", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDeterministicCborMap {
    fn drop(&mut self) {
        __reallyme_zeroize_message_vec(&mut self.entries);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDeterministicCborMap {}
impl<'de> ::serde::Deserialize<'de> for CodecDeterministicCborMap {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "entries")]
            entries: ::buffa::alloc::vec::Vec<CodecDeterministicCborMapEntry>,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            entries: ::core::mem::take(&mut wire.entries),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecDeterministicCborMap {
    /// 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/reallyme.codec.v1.CodecDeterministicCborMap";
}
::buffa::impl_default_instance!(CodecDeterministicCborMap);
impl ::buffa::MessageName for CodecDeterministicCborMap {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborMap";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborMap";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborMap";
}
impl ::buffa::Message for CodecDeterministicCborMap {
    /// 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.entries {
            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.entries {
            ::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.entries.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        __reallyme_zeroize_message_vec(&mut self.entries);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDeterministicCborMap {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDeterministicCborMap";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDeterministicCborMap {
    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)]
pub const __CODEC_DETERMINISTIC_CBOR_MAP_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborMap",
    to_json: ::buffa::type_registry::any_to_json::<CodecDeterministicCborMap>,
    from_json: ::buffa::type_registry::any_from_json::<CodecDeterministicCborMap>,
    is_wkt: false,
};
/// CodecDeterministicCborValue is the generated transport form of the
/// deterministic generic-CBOR semantic tree. Text, bytes, and keys are treated
/// as sensitive by generated hardening because this is a generic codec surface.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDeterministicCborValue {
    #[serde(flatten)]
    pub value: ::core::option::Option<
        __buffa::oneof::codec_deterministic_cbor_value::Value,
    >,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDeterministicCborValue {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborValue")
            .field("value", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDeterministicCborValue {
    fn drop(&mut self) {
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDeterministicCborValue {}
impl CodecDeterministicCborValue {
    /// 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/reallyme.codec.v1.CodecDeterministicCborValue";
}
::buffa::impl_default_instance!(CodecDeterministicCborValue);
impl ::buffa::MessageName for CodecDeterministicCborValue {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborValue";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborValue";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborValue";
}
impl ::buffa::Message for CodecDeterministicCborValue {
    /// 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 ::core::option::Option::Some(ref v) = self.value {
            match v {
                __buffa::oneof::codec_deterministic_cbor_value::Value::NullValue(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_deterministic_cbor_value::Value::BoolValue(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_deterministic_cbor_value::Value::IntegerValue(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_deterministic_cbor_value::Value::TextValue(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_deterministic_cbor_value::Value::BytesValue(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_deterministic_cbor_value::Value::ArrayValue(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_deterministic_cbor_value::Value::MapValue(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner 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 ::core::option::Option::Some(ref v) = self.value {
            match v {
                __buffa::oneof::codec_deterministic_cbor_value::Value::NullValue(x) => {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_deterministic_cbor_value::Value::BoolValue(x) => {
                    ::buffa::types::put_len_delimited_header(
                        2u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_deterministic_cbor_value::Value::IntegerValue(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        3u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_deterministic_cbor_value::Value::TextValue(x) => {
                    ::buffa::types::put_len_delimited_header(
                        4u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_deterministic_cbor_value::Value::BytesValue(x) => {
                    ::buffa::types::put_len_delimited_header(
                        5u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_deterministic_cbor_value::Value::ArrayValue(x) => {
                    ::buffa::types::put_len_delimited_header(
                        6u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_deterministic_cbor_value::Value::MapValue(x) => {
                    ::buffa::types::put_len_delimited_header(
                        7u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.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,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_deterministic_cbor_value::Value::NullValue(
                        ref mut existing,
                    ),
                ) = self.value
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.value = ::core::option::Option::Some(
                        __buffa::oneof::codec_deterministic_cbor_value::Value::NullValue(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_deterministic_cbor_value::Value::BoolValue(
                        ref mut existing,
                    ),
                ) = self.value
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.value = ::core::option::Option::Some(
                        __buffa::oneof::codec_deterministic_cbor_value::Value::BoolValue(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_deterministic_cbor_value::Value::IntegerValue(
                        ref mut existing,
                    ),
                ) = self.value
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.value = ::core::option::Option::Some(
                        __buffa::oneof::codec_deterministic_cbor_value::Value::IntegerValue(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_deterministic_cbor_value::Value::TextValue(
                        ref mut existing,
                    ),
                ) = self.value
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.value = ::core::option::Option::Some(
                        __buffa::oneof::codec_deterministic_cbor_value::Value::TextValue(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_deterministic_cbor_value::Value::BytesValue(
                        ref mut existing,
                    ),
                ) = self.value
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.value = ::core::option::Option::Some(
                        __buffa::oneof::codec_deterministic_cbor_value::Value::BytesValue(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_deterministic_cbor_value::Value::ArrayValue(
                        ref mut existing,
                    ),
                ) = self.value
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.value = ::core::option::Option::Some(
                        __buffa::oneof::codec_deterministic_cbor_value::Value::ArrayValue(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_deterministic_cbor_value::Value::MapValue(
                        ref mut existing,
                    ),
                ) = self.value
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.value = ::core::option::Option::Some(
                        __buffa::oneof::codec_deterministic_cbor_value::Value::MapValue(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            _ => {
                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;
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDeterministicCborValue {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDeterministicCborValue";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl<'de> ::serde::Deserialize<'de> for CodecDeterministicCborValue {
    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 = CodecDeterministicCborValue;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str("struct CodecDeterministicCborValue")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: ::serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<CodecDeterministicCborValue, A::Error> {
                let mut __oneof_value: ::core::option::Option<
                    __buffa::oneof::codec_deterministic_cbor_value::Value,
                > = None;
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "nullValue" | "null_value" => {
                            let v: ::core::option::Option<CodecDeterministicCborNull> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDeterministicCborNull,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_value.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'value'",
                                        ),
                                    );
                                }
                                __oneof_value = Some(
                                    __buffa::oneof::codec_deterministic_cbor_value::Value::NullValue(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "boolValue" | "bool_value" => {
                            let v: ::core::option::Option<CodecDeterministicCborBool> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDeterministicCborBool,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_value.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'value'",
                                        ),
                                    );
                                }
                                __oneof_value = Some(
                                    __buffa::oneof::codec_deterministic_cbor_value::Value::BoolValue(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "integerValue" | "integer_value" => {
                            let v: ::core::option::Option<
                                CodecDeterministicCborInteger,
                            > = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDeterministicCborInteger,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_value.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'value'",
                                        ),
                                    );
                                }
                                __oneof_value = Some(
                                    __buffa::oneof::codec_deterministic_cbor_value::Value::IntegerValue(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "textValue" | "text_value" => {
                            let v: ::core::option::Option<CodecDeterministicCborText> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDeterministicCborText,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_value.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'value'",
                                        ),
                                    );
                                }
                                __oneof_value = Some(
                                    __buffa::oneof::codec_deterministic_cbor_value::Value::TextValue(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "bytesValue" | "bytes_value" => {
                            let v: ::core::option::Option<CodecDeterministicCborBytes> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDeterministicCborBytes,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_value.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'value'",
                                        ),
                                    );
                                }
                                __oneof_value = Some(
                                    __buffa::oneof::codec_deterministic_cbor_value::Value::BytesValue(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "arrayValue" | "array_value" => {
                            let v: ::core::option::Option<CodecDeterministicCborArray> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDeterministicCborArray,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_value.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'value'",
                                        ),
                                    );
                                }
                                __oneof_value = Some(
                                    __buffa::oneof::codec_deterministic_cbor_value::Value::ArrayValue(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "mapValue" | "map_value" => {
                            let v: ::core::option::Option<CodecDeterministicCborMap> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDeterministicCborMap,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_value.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'value'",
                                        ),
                                    );
                                }
                                __oneof_value = Some(
                                    __buffa::oneof::codec_deterministic_cbor_value::Value::MapValue(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        _ => {
                            return Err(::serde::de::Error::custom("unknown field"));
                        }
                    }
                }
                let mut __r = <CodecDeterministicCborValue as ::core::default::Default>::default();
                __r.value = __oneof_value;
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDeterministicCborValue {
    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)]
pub const __CODEC_DETERMINISTIC_CBOR_VALUE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborValue",
    to_json: ::buffa::type_registry::any_to_json::<CodecDeterministicCborValue>,
    from_json: ::buffa::type_registry::any_from_json::<CodecDeterministicCborValue>,
    is_wkt: false,
};
pub mod codec_deterministic_cbor_value {
    #[allow(unused_imports)]
    use super::*;
    #[doc(inline)]
    pub use super::__buffa::oneof::codec_deterministic_cbor_value::Value;
    #[doc(inline)]
    pub use super::__buffa::view::oneof::codec_deterministic_cbor_value::Value as ValueView;
}
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDeterministicCborEncodeRequest {
    /// Field 1: `value`
    #[serde(
        rename = "value",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub value: ::buffa::MessageField<
        CodecDeterministicCborValue,
        ::buffa::Inline<CodecDeterministicCborValue>,
    >,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDeterministicCborEncodeRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborEncodeRequest")
            .field("value", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDeterministicCborEncodeRequest {
    fn drop(&mut self) {
        __reallyme_zeroize_message_field(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDeterministicCborEncodeRequest {}
impl<'de> ::serde::Deserialize<'de> for CodecDeterministicCborEncodeRequest {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "value")]
            value: ::buffa::MessageField<
        CodecDeterministicCborValue,
        ::buffa::Inline<CodecDeterministicCborValue>,
    >,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            value: ::core::mem::take(&mut wire.value),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecDeterministicCborEncodeRequest {
    /// 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/reallyme.codec.v1.CodecDeterministicCborEncodeRequest";
}
::buffa::impl_default_instance!(CodecDeterministicCborEncodeRequest);
impl ::buffa::MessageName for CodecDeterministicCborEncodeRequest {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborEncodeRequest";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborEncodeRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborEncodeRequest";
}
impl ::buffa::Message for CodecDeterministicCborEncodeRequest {
    /// 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.value.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.value.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 self.value.is_set() {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.value.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.value.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) {
        __reallyme_zeroize_message_field(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDeterministicCborEncodeRequest {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDeterministicCborEncodeRequest";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDeterministicCborEncodeRequest {
    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)]
pub const __CODEC_DETERMINISTIC_CBOR_ENCODE_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborEncodeRequest",
    to_json: ::buffa::type_registry::any_to_json::<CodecDeterministicCborEncodeRequest>,
    from_json: ::buffa::type_registry::any_from_json::<
        CodecDeterministicCborEncodeRequest,
    >,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDeterministicCborEncodeResult {
    /// Encoded CBOR bytes may contain the complete sensitive document.
    ///
    /// Field 1: `encoded`
    #[serde(
        rename = "encoded",
        serialize_with = "__reallyme_serialize_sensitive_bytes",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_bytes"
    )]
    pub encoded: ::buffa::alloc::vec::Vec<u8>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDeterministicCborEncodeResult {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborEncodeResult")
            .field("encoded", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDeterministicCborEncodeResult {
    fn drop(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.encoded);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDeterministicCborEncodeResult {}
impl<'de> ::serde::Deserialize<'de> for CodecDeterministicCborEncodeResult {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "encoded", deserialize_with = "deserialize_zeroizing_bytes")]
            encoded: ::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            encoded: ::core::mem::take(&mut *wire.encoded),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecDeterministicCborEncodeResult {
    /// 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/reallyme.codec.v1.CodecDeterministicCborEncodeResult";
}
::buffa::impl_default_instance!(CodecDeterministicCborEncodeResult);
impl ::buffa::MessageName for CodecDeterministicCborEncodeResult {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborEncodeResult";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborEncodeResult";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborEncodeResult";
}
impl ::buffa::Message for CodecDeterministicCborEncodeResult {
    /// 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.encoded.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.encoded) 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.encoded.is_empty() {
            ::buffa::types::put_shared_bytes_field(1u32, &self.encoded, 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,
                )?;
                ::zeroize::Zeroize::zeroize(&mut self.encoded);
                ::buffa::types::merge_bytes(&mut self.encoded, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.encoded);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDeterministicCborEncodeResult {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDeterministicCborEncodeResult";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDeterministicCborEncodeResult {
    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)]
pub const __CODEC_DETERMINISTIC_CBOR_ENCODE_RESULT_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborEncodeResult",
    to_json: ::buffa::type_registry::any_to_json::<CodecDeterministicCborEncodeResult>,
    from_json: ::buffa::type_registry::any_from_json::<
        CodecDeterministicCborEncodeResult,
    >,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDeterministicCborDecodeRequest {
    /// Encoded CBOR bytes may contain the complete sensitive document.
    ///
    /// Field 1: `encoded`
    #[serde(
        rename = "encoded",
        serialize_with = "__reallyme_serialize_sensitive_bytes",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_bytes"
    )]
    pub encoded: ::buffa::alloc::vec::Vec<u8>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDeterministicCborDecodeRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborDecodeRequest")
            .field("encoded", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDeterministicCborDecodeRequest {
    fn drop(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.encoded);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDeterministicCborDecodeRequest {}
impl<'de> ::serde::Deserialize<'de> for CodecDeterministicCborDecodeRequest {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "encoded", deserialize_with = "deserialize_zeroizing_bytes")]
            encoded: ::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            encoded: ::core::mem::take(&mut *wire.encoded),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecDeterministicCborDecodeRequest {
    /// 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/reallyme.codec.v1.CodecDeterministicCborDecodeRequest";
}
::buffa::impl_default_instance!(CodecDeterministicCborDecodeRequest);
impl ::buffa::MessageName for CodecDeterministicCborDecodeRequest {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborDecodeRequest";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborDecodeRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborDecodeRequest";
}
impl ::buffa::Message for CodecDeterministicCborDecodeRequest {
    /// 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.encoded.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.encoded) 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.encoded.is_empty() {
            ::buffa::types::put_shared_bytes_field(1u32, &self.encoded, 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,
                )?;
                ::zeroize::Zeroize::zeroize(&mut self.encoded);
                ::buffa::types::merge_bytes(&mut self.encoded, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.encoded);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDeterministicCborDecodeRequest {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDeterministicCborDecodeRequest";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDeterministicCborDecodeRequest {
    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)]
pub const __CODEC_DETERMINISTIC_CBOR_DECODE_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborDecodeRequest",
    to_json: ::buffa::type_registry::any_to_json::<CodecDeterministicCborDecodeRequest>,
    from_json: ::buffa::type_registry::any_from_json::<
        CodecDeterministicCborDecodeRequest,
    >,
    is_wkt: false,
};
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDeterministicCborDecodeResult {
    /// Field 1: `value`
    #[serde(
        rename = "value",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub value: ::buffa::MessageField<
        CodecDeterministicCborValue,
        ::buffa::Inline<CodecDeterministicCborValue>,
    >,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDeterministicCborDecodeResult {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborDecodeResult")
            .field("value", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecDeterministicCborDecodeResult {
    fn drop(&mut self) {
        __reallyme_zeroize_message_field(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecDeterministicCborDecodeResult {}
impl<'de> ::serde::Deserialize<'de> for CodecDeterministicCborDecodeResult {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "value")]
            value: ::buffa::MessageField<
        CodecDeterministicCborValue,
        ::buffa::Inline<CodecDeterministicCborValue>,
    >,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            value: ::core::mem::take(&mut wire.value),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecDeterministicCborDecodeResult {
    /// 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/reallyme.codec.v1.CodecDeterministicCborDecodeResult";
}
::buffa::impl_default_instance!(CodecDeterministicCborDecodeResult);
impl ::buffa::MessageName for CodecDeterministicCborDecodeResult {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborDecodeResult";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborDecodeResult";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborDecodeResult";
}
impl ::buffa::Message for CodecDeterministicCborDecodeResult {
    /// 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.value.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.value.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 self.value.is_set() {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.value.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.value.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) {
        __reallyme_zeroize_message_field(&mut self.value);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDeterministicCborDecodeResult {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDeterministicCborDecodeResult";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDeterministicCborDecodeResult {
    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)]
pub const __CODEC_DETERMINISTIC_CBOR_DECODE_RESULT_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborDecodeResult",
    to_json: ::buffa::type_registry::any_to_json::<CodecDeterministicCborDecodeResult>,
    from_json: ::buffa::type_registry::any_from_json::<
        CodecDeterministicCborDecodeResult,
    >,
    is_wkt: false,
};
/// CodecOperationResult is the fully discriminated generated result contract for
/// structured operations.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecOperationResult {
    #[serde(flatten)]
    pub result: ::core::option::Option<__buffa::oneof::codec_operation_result::Result>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecOperationResult {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecOperationResult").field("result", &"<redacted>").finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecOperationResult {
    fn drop(&mut self) {
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecOperationResult {}
impl CodecOperationResult {
    /// 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/reallyme.codec.v1.CodecOperationResult";
}
::buffa::impl_default_instance!(CodecOperationResult);
impl ::buffa::MessageName for CodecOperationResult {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecOperationResult";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecOperationResult";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecOperationResult";
}
impl ::buffa::Message for CodecOperationResult {
    /// 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 ::core::option::Option::Some(ref v) = self.result {
            match v {
                __buffa::oneof::codec_operation_result::Result::MulticodecPrefixForName(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_result::Result::MulticodecLookupPrefix(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_result::Result::MulticodecTable(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_result::Result::MultikeyParse(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_result::Result::DagCborVerifyCid(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_result::Result::DagCborEncode(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_result::Result::DagCborDecode(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_result::Result::PemDecode(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_result::Result::PemEncode(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_result::Result::DeterministicCborEncode(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_result::Result::DeterministicCborDecode(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner 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 ::core::option::Option::Some(ref v) = self.result {
            match v {
                __buffa::oneof::codec_operation_result::Result::MulticodecPrefixForName(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_result::Result::MulticodecLookupPrefix(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1001u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_result::Result::MulticodecTable(x) => {
                    ::buffa::types::put_len_delimited_header(
                        1002u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_result::Result::MultikeyParse(x) => {
                    ::buffa::types::put_len_delimited_header(
                        2000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_result::Result::DagCborVerifyCid(x) => {
                    ::buffa::types::put_len_delimited_header(
                        3000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_result::Result::DagCborEncode(x) => {
                    ::buffa::types::put_len_delimited_header(
                        3001u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_result::Result::DagCborDecode(x) => {
                    ::buffa::types::put_len_delimited_header(
                        3002u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_result::Result::PemDecode(x) => {
                    ::buffa::types::put_len_delimited_header(
                        4000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_result::Result::PemEncode(x) => {
                    ::buffa::types::put_len_delimited_header(
                        4001u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_result::Result::DeterministicCborEncode(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        5000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_result::Result::DeterministicCborDecode(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        5001u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.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() {
            1000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_result::Result::MulticodecPrefixForName(
                        ref mut existing,
                    ),
                ) = self.result
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.result = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_result::Result::MulticodecPrefixForName(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            1001u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_result::Result::MulticodecLookupPrefix(
                        ref mut existing,
                    ),
                ) = self.result
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.result = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_result::Result::MulticodecLookupPrefix(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            1002u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_result::Result::MulticodecTable(
                        ref mut existing,
                    ),
                ) = self.result
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.result = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_result::Result::MulticodecTable(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            2000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_result::Result::MultikeyParse(
                        ref mut existing,
                    ),
                ) = self.result
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.result = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_result::Result::MultikeyParse(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            3000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_result::Result::DagCborVerifyCid(
                        ref mut existing,
                    ),
                ) = self.result
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.result = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_result::Result::DagCborVerifyCid(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            3001u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_result::Result::DagCborEncode(
                        ref mut existing,
                    ),
                ) = self.result
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.result = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_result::Result::DagCborEncode(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            3002u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_result::Result::DagCborDecode(
                        ref mut existing,
                    ),
                ) = self.result
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.result = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_result::Result::DagCborDecode(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            4000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_result::Result::PemDecode(
                        ref mut existing,
                    ),
                ) = self.result
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.result = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_result::Result::PemDecode(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            4001u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_result::Result::PemEncode(
                        ref mut existing,
                    ),
                ) = self.result
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.result = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_result::Result::PemEncode(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            5000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_result::Result::DeterministicCborEncode(
                        ref mut existing,
                    ),
                ) = self.result
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.result = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_result::Result::DeterministicCborEncode(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            5001u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_result::Result::DeterministicCborDecode(
                        ref mut existing,
                    ),
                ) = self.result
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.result = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_result::Result::DeterministicCborDecode(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.result = ::core::option::Option::None;
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecOperationResult {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecOperationResult";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl<'de> ::serde::Deserialize<'de> for CodecOperationResult {
    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 = CodecOperationResult;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str("struct CodecOperationResult")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: ::serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<CodecOperationResult, A::Error> {
                let mut __oneof_result: ::core::option::Option<
                    __buffa::oneof::codec_operation_result::Result,
                > = None;
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "multicodecPrefixForName" | "multicodec_prefix_for_name" => {
                            let v: ::core::option::Option<CodecMulticodecSpec> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecMulticodecSpec,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_result.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'result'",
                                        ),
                                    );
                                }
                                __oneof_result = Some(
                                    __buffa::oneof::codec_operation_result::Result::MulticodecPrefixForName(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "multicodecLookupPrefix" | "multicodec_lookup_prefix" => {
                            let v: ::core::option::Option<CodecMulticodecLookupResult> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecMulticodecLookupResult,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_result.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'result'",
                                        ),
                                    );
                                }
                                __oneof_result = Some(
                                    __buffa::oneof::codec_operation_result::Result::MulticodecLookupPrefix(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "multicodecTable" | "multicodec_table" => {
                            let v: ::core::option::Option<CodecMulticodecTableResult> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecMulticodecTableResult,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_result.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'result'",
                                        ),
                                    );
                                }
                                __oneof_result = Some(
                                    __buffa::oneof::codec_operation_result::Result::MulticodecTable(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "multikeyParse" | "multikey_parse" => {
                            let v: ::core::option::Option<CodecMultikeyParseResult> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecMultikeyParseResult,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_result.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'result'",
                                        ),
                                    );
                                }
                                __oneof_result = Some(
                                    __buffa::oneof::codec_operation_result::Result::MultikeyParse(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "dagCborVerifyCid" | "dag_cbor_verify_cid" => {
                            let v: ::core::option::Option<CodecDagCborVerifyCidResult> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDagCborVerifyCidResult,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_result.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'result'",
                                        ),
                                    );
                                }
                                __oneof_result = Some(
                                    __buffa::oneof::codec_operation_result::Result::DagCborVerifyCid(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "dagCborEncode" | "dag_cbor_encode" => {
                            let v: ::core::option::Option<CodecDagCborEncodeResult> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDagCborEncodeResult,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_result.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'result'",
                                        ),
                                    );
                                }
                                __oneof_result = Some(
                                    __buffa::oneof::codec_operation_result::Result::DagCborEncode(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "dagCborDecode" | "dag_cbor_decode" => {
                            let v: ::core::option::Option<CodecDagCborDecodeResult> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDagCborDecodeResult,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_result.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'result'",
                                        ),
                                    );
                                }
                                __oneof_result = Some(
                                    __buffa::oneof::codec_operation_result::Result::DagCborDecode(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "pemDecode" | "pem_decode" => {
                            let v: ::core::option::Option<CodecPemDecodeResult> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecPemDecodeResult,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_result.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'result'",
                                        ),
                                    );
                                }
                                __oneof_result = Some(
                                    __buffa::oneof::codec_operation_result::Result::PemDecode(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "pemEncode" | "pem_encode" => {
                            let v: ::core::option::Option<CodecPemEncodeResult> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecPemEncodeResult,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_result.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'result'",
                                        ),
                                    );
                                }
                                __oneof_result = Some(
                                    __buffa::oneof::codec_operation_result::Result::PemEncode(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "deterministicCborEncode" | "deterministic_cbor_encode" => {
                            let v: ::core::option::Option<
                                CodecDeterministicCborEncodeResult,
                            > = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDeterministicCborEncodeResult,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_result.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'result'",
                                        ),
                                    );
                                }
                                __oneof_result = Some(
                                    __buffa::oneof::codec_operation_result::Result::DeterministicCborEncode(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "deterministicCborDecode" | "deterministic_cbor_decode" => {
                            let v: ::core::option::Option<
                                CodecDeterministicCborDecodeResult,
                            > = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDeterministicCborDecodeResult,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_result.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'result'",
                                        ),
                                    );
                                }
                                __oneof_result = Some(
                                    __buffa::oneof::codec_operation_result::Result::DeterministicCborDecode(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        _ => {
                            return Err(::serde::de::Error::custom("unknown field"));
                        }
                    }
                }
                let mut __r = <CodecOperationResult as ::core::default::Default>::default();
                __r.result = __oneof_result;
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecOperationResult {
    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)]
pub const __CODEC_OPERATION_RESULT_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecOperationResult",
    to_json: ::buffa::type_registry::any_to_json::<CodecOperationResult>,
    from_json: ::buffa::type_registry::any_from_json::<CodecOperationResult>,
    is_wkt: false,
};
pub mod codec_operation_result {
    #[allow(unused_imports)]
    use super::*;
    #[doc(inline)]
    pub use super::__buffa::oneof::codec_operation_result::Result;
    #[doc(inline)]
    pub use super::__buffa::view::oneof::codec_operation_result::Result as ResultView;
}
/// CodecOperationResponse removes invalid status/payload combinations for new
/// structured callers by making success and failure explicit generated variants.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecOperationResponse {
    #[serde(flatten)]
    pub outcome: ::core::option::Option<
        __buffa::oneof::codec_operation_response::Outcome,
    >,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecOperationResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecOperationResponse").field("outcome", &"<redacted>").finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecOperationResponse {
    fn drop(&mut self) {
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecOperationResponse {}
impl CodecOperationResponse {
    /// 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/reallyme.codec.v1.CodecOperationResponse";
}
::buffa::impl_default_instance!(CodecOperationResponse);
impl ::buffa::MessageName for CodecOperationResponse {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecOperationResponse";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecOperationResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecOperationResponse";
}
impl ::buffa::Message for CodecOperationResponse {
    /// 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 ::core::option::Option::Some(ref v) = self.outcome {
            match v {
                __buffa::oneof::codec_operation_response::Outcome::Result(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_response::Outcome::Error(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner 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 ::core::option::Option::Some(ref v) = self.outcome {
            match v {
                __buffa::oneof::codec_operation_response::Outcome::Result(x) => {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_response::Outcome::Error(x) => {
                    ::buffa::types::put_len_delimited_header(
                        2u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.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,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_response::Outcome::Result(
                        ref mut existing,
                    ),
                ) = self.outcome
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.outcome = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_response::Outcome::Result(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_response::Outcome::Error(
                        ref mut existing,
                    ),
                ) = self.outcome
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.outcome = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_response::Outcome::Error(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.outcome = ::core::option::Option::None;
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecOperationResponse {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecOperationResponse";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl<'de> ::serde::Deserialize<'de> for CodecOperationResponse {
    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 = CodecOperationResponse;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str("struct CodecOperationResponse")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: ::serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<CodecOperationResponse, A::Error> {
                let mut __oneof_outcome: ::core::option::Option<
                    __buffa::oneof::codec_operation_response::Outcome,
                > = None;
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "result" => {
                            let v: ::core::option::Option<CodecOperationResult> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecOperationResult,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_outcome.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'outcome'",
                                        ),
                                    );
                                }
                                __oneof_outcome = Some(
                                    __buffa::oneof::codec_operation_response::Outcome::Result(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "error" => {
                            let v: ::core::option::Option<CodecError> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecError,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_outcome.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'outcome'",
                                        ),
                                    );
                                }
                                __oneof_outcome = Some(
                                    __buffa::oneof::codec_operation_response::Outcome::Error(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        _ => {
                            return Err(::serde::de::Error::custom("unknown field"));
                        }
                    }
                }
                let mut __r = <CodecOperationResponse as ::core::default::Default>::default();
                __r.outcome = __oneof_outcome;
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecOperationResponse {
    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)]
pub const __CODEC_OPERATION_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecOperationResponse",
    to_json: ::buffa::type_registry::any_to_json::<CodecOperationResponse>,
    from_json: ::buffa::type_registry::any_from_json::<CodecOperationResponse>,
    is_wkt: false,
};
pub mod codec_operation_response {
    #[allow(unused_imports)]
    use super::*;
    #[doc(inline)]
    pub use super::__buffa::oneof::codec_operation_response::Outcome;
    #[doc(inline)]
    pub use super::__buffa::view::oneof::codec_operation_response::Outcome as OutcomeView;
}
/// CodecOperationRequest is the single executable protobuf request. Native SDK
/// callers continue to use typed methods; binary protobuf and generated
/// ProtoJSON adapters select exactly one operation through this oneof. Sparse
/// field bands keep related codec families together without creating a second
/// out-of-band operation namespace.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecOperationRequest {
    #[serde(flatten)]
    pub operation: ::core::option::Option<
        __buffa::oneof::codec_operation_request::Operation,
    >,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecOperationRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecOperationRequest")
            .field("operation", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecOperationRequest {
    fn drop(&mut self) {
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecOperationRequest {}
impl CodecOperationRequest {
    /// 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/reallyme.codec.v1.CodecOperationRequest";
}
::buffa::impl_default_instance!(CodecOperationRequest);
impl ::buffa::MessageName for CodecOperationRequest {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecOperationRequest";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecOperationRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecOperationRequest";
}
impl ::buffa::Message for CodecOperationRequest {
    /// 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 ::core::option::Option::Some(ref v) = self.operation {
            match v {
                __buffa::oneof::codec_operation_request::Operation::MulticodecPrefixForName(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_request::Operation::MulticodecLookupPrefix(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_request::Operation::MulticodecTable(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_request::Operation::MultikeyParse(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_request::Operation::DagCborVerifyCid(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_request::Operation::DagCborEncode(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_request::Operation::DagCborDecode(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_request::Operation::PemDecode(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_request::Operation::PemEncode(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_request::Operation::DeterministicCborEncode(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::codec_operation_request::Operation::DeterministicCborDecode(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner 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 ::core::option::Option::Some(ref v) = self.operation {
            match v {
                __buffa::oneof::codec_operation_request::Operation::MulticodecPrefixForName(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_request::Operation::MulticodecLookupPrefix(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1001u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_request::Operation::MulticodecTable(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1002u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_request::Operation::MultikeyParse(x) => {
                    ::buffa::types::put_len_delimited_header(
                        2000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_request::Operation::DagCborVerifyCid(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        3000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_request::Operation::DagCborEncode(x) => {
                    ::buffa::types::put_len_delimited_header(
                        3001u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_request::Operation::DagCborDecode(x) => {
                    ::buffa::types::put_len_delimited_header(
                        3002u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_request::Operation::PemDecode(x) => {
                    ::buffa::types::put_len_delimited_header(
                        4000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_request::Operation::PemEncode(x) => {
                    ::buffa::types::put_len_delimited_header(
                        4001u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_request::Operation::DeterministicCborEncode(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        5000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_request::Operation::DeterministicCborDecode(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        5001u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.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() {
            1000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_request::Operation::MulticodecPrefixForName(
                        ref mut existing,
                    ),
                ) = self.operation
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.operation = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_request::Operation::MulticodecPrefixForName(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            1001u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_request::Operation::MulticodecLookupPrefix(
                        ref mut existing,
                    ),
                ) = self.operation
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.operation = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_request::Operation::MulticodecLookupPrefix(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            1002u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_request::Operation::MulticodecTable(
                        ref mut existing,
                    ),
                ) = self.operation
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.operation = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_request::Operation::MulticodecTable(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            2000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_request::Operation::MultikeyParse(
                        ref mut existing,
                    ),
                ) = self.operation
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.operation = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_request::Operation::MultikeyParse(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            3000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_request::Operation::DagCborVerifyCid(
                        ref mut existing,
                    ),
                ) = self.operation
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.operation = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_request::Operation::DagCborVerifyCid(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            3001u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_request::Operation::DagCborEncode(
                        ref mut existing,
                    ),
                ) = self.operation
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.operation = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_request::Operation::DagCborEncode(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            3002u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_request::Operation::DagCborDecode(
                        ref mut existing,
                    ),
                ) = self.operation
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.operation = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_request::Operation::DagCborDecode(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            4000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_request::Operation::PemDecode(
                        ref mut existing,
                    ),
                ) = self.operation
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.operation = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_request::Operation::PemDecode(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            4001u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_request::Operation::PemEncode(
                        ref mut existing,
                    ),
                ) = self.operation
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.operation = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_request::Operation::PemEncode(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            5000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_request::Operation::DeterministicCborEncode(
                        ref mut existing,
                    ),
                ) = self.operation
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.operation = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_request::Operation::DeterministicCborEncode(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            5001u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::codec_operation_request::Operation::DeterministicCborDecode(
                        ref mut existing,
                    ),
                ) = self.operation
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.operation = ::core::option::Option::Some(
                        __buffa::oneof::codec_operation_request::Operation::DeterministicCborDecode(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.operation = ::core::option::Option::None;
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecOperationRequest {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecOperationRequest";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl<'de> ::serde::Deserialize<'de> for CodecOperationRequest {
    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 = CodecOperationRequest;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str("struct CodecOperationRequest")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: ::serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<CodecOperationRequest, A::Error> {
                let mut __oneof_operation: ::core::option::Option<
                    __buffa::oneof::codec_operation_request::Operation,
                > = None;
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "multicodecPrefixForName" | "multicodec_prefix_for_name" => {
                            let v: ::core::option::Option<
                                CodecMulticodecPrefixForNameRequest,
                            > = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecMulticodecPrefixForNameRequest,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_operation.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'operation'",
                                        ),
                                    );
                                }
                                __oneof_operation = Some(
                                    __buffa::oneof::codec_operation_request::Operation::MulticodecPrefixForName(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "multicodecLookupPrefix" | "multicodec_lookup_prefix" => {
                            let v: ::core::option::Option<
                                CodecMulticodecLookupPrefixRequest,
                            > = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecMulticodecLookupPrefixRequest,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_operation.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'operation'",
                                        ),
                                    );
                                }
                                __oneof_operation = Some(
                                    __buffa::oneof::codec_operation_request::Operation::MulticodecLookupPrefix(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "multicodecTable" | "multicodec_table" => {
                            let v: ::core::option::Option<CodecMulticodecTableRequest> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecMulticodecTableRequest,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_operation.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'operation'",
                                        ),
                                    );
                                }
                                __oneof_operation = Some(
                                    __buffa::oneof::codec_operation_request::Operation::MulticodecTable(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "multikeyParse" | "multikey_parse" => {
                            let v: ::core::option::Option<CodecMultikeyParseRequest> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecMultikeyParseRequest,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_operation.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'operation'",
                                        ),
                                    );
                                }
                                __oneof_operation = Some(
                                    __buffa::oneof::codec_operation_request::Operation::MultikeyParse(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "dagCborVerifyCid" | "dag_cbor_verify_cid" => {
                            let v: ::core::option::Option<
                                CodecDagCborVerifyCidRequest,
                            > = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDagCborVerifyCidRequest,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_operation.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'operation'",
                                        ),
                                    );
                                }
                                __oneof_operation = Some(
                                    __buffa::oneof::codec_operation_request::Operation::DagCborVerifyCid(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "dagCborEncode" | "dag_cbor_encode" => {
                            let v: ::core::option::Option<CodecDagCborEncodeRequest> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDagCborEncodeRequest,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_operation.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'operation'",
                                        ),
                                    );
                                }
                                __oneof_operation = Some(
                                    __buffa::oneof::codec_operation_request::Operation::DagCborEncode(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "dagCborDecode" | "dag_cbor_decode" => {
                            let v: ::core::option::Option<CodecDagCborDecodeRequest> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDagCborDecodeRequest,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_operation.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'operation'",
                                        ),
                                    );
                                }
                                __oneof_operation = Some(
                                    __buffa::oneof::codec_operation_request::Operation::DagCborDecode(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "pemDecode" | "pem_decode" => {
                            let v: ::core::option::Option<CodecPemDecodeRequest> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecPemDecodeRequest,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_operation.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'operation'",
                                        ),
                                    );
                                }
                                __oneof_operation = Some(
                                    __buffa::oneof::codec_operation_request::Operation::PemDecode(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "pemEncode" | "pem_encode" => {
                            let v: ::core::option::Option<CodecPemEncodeRequest> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecPemEncodeRequest,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_operation.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'operation'",
                                        ),
                                    );
                                }
                                __oneof_operation = Some(
                                    __buffa::oneof::codec_operation_request::Operation::PemEncode(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "deterministicCborEncode" | "deterministic_cbor_encode" => {
                            let v: ::core::option::Option<
                                CodecDeterministicCborEncodeRequest,
                            > = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDeterministicCborEncodeRequest,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_operation.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'operation'",
                                        ),
                                    );
                                }
                                __oneof_operation = Some(
                                    __buffa::oneof::codec_operation_request::Operation::DeterministicCborEncode(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "deterministicCborDecode" | "deterministic_cbor_decode" => {
                            let v: ::core::option::Option<
                                CodecDeterministicCborDecodeRequest,
                            > = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            CodecDeterministicCborDecodeRequest,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_operation.is_some() {
                                    return Err(
                                        ::serde::de::Error::custom(
                                            "multiple oneof fields set for 'operation'",
                                        ),
                                    );
                                }
                                __oneof_operation = Some(
                                    __buffa::oneof::codec_operation_request::Operation::DeterministicCborDecode(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        _ => {
                            return Err(::serde::de::Error::custom("unknown field"));
                        }
                    }
                }
                let mut __r = <CodecOperationRequest as ::core::default::Default>::default();
                __r.operation = __oneof_operation;
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecOperationRequest {
    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)]
pub const __CODEC_OPERATION_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecOperationRequest",
    to_json: ::buffa::type_registry::any_to_json::<CodecOperationRequest>,
    from_json: ::buffa::type_registry::any_from_json::<CodecOperationRequest>,
    is_wkt: false,
};
pub mod codec_operation_request {
    #[allow(unused_imports)]
    use super::*;
    #[doc(inline)]
    pub use super::__buffa::oneof::codec_operation_request::Operation;
    #[doc(inline)]
    pub use super::__buffa::view::oneof::codec_operation_request::Operation as OperationView;
}
/// CodecMulticodecSpec is the protobuf form of a multicodec table entry.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecMulticodecSpec {
    /// Field 1: `name`
    #[serde(
        rename = "name",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub name: ::buffa::alloc::string::String,
    /// Raw multicodec varint bytes for callers that need the numeric code
    /// encoding independent of any payload.
    ///
    /// Field 2: `code`
    #[serde(
        rename = "code",
        with = "::buffa::json_helpers::bytes",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_bytes"
    )]
    pub code: ::buffa::alloc::vec::Vec<u8>,
    /// Prefix bytes to match or prepend on encoded values. For currently
    /// supported codecs this is identical to code, but it is kept separate so
    /// consumers can use semantic field names without deriving one from the
    /// other.
    ///
    /// Field 3: `prefix`
    #[serde(
        rename = "prefix",
        with = "::buffa::json_helpers::bytes",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_bytes"
    )]
    pub prefix: ::buffa::alloc::vec::Vec<u8>,
    /// Field 4: `tag`
    #[serde(
        rename = "tag",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub tag: ::buffa::EnumValue<CodecTag>,
    /// Field 5: `key_material_kind`
    #[serde(
        rename = "keyMaterialKind",
        alias = "key_material_kind",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub key_material_kind: ::buffa::EnumValue<CodecKeyMaterialKind>,
    /// Field 6: `fixed_length`
    #[serde(
        rename = "fixedLength",
        alias = "fixed_length",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub fixed_length: u32,
    /// Field 7: `variable_length`
    #[serde(
        rename = "variableLength",
        alias = "variable_length",
        with = "::buffa::json_helpers::proto_bool",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
    )]
    pub variable_length: bool,
    /// Field 8: `algorithm_name`
    #[serde(
        rename = "algorithmName",
        alias = "algorithm_name",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub algorithm_name: ::buffa::alloc::string::String,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecMulticodecSpec {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecMulticodecSpec")
            .field("name", &self.name)
            .field("code", &self.code)
            .field("prefix", &self.prefix)
            .field("tag", &self.tag)
            .field("key_material_kind", &self.key_material_kind)
            .field("fixed_length", &self.fixed_length)
            .field("variable_length", &self.variable_length)
            .field("algorithm_name", &self.algorithm_name)
            .finish()
    }
}
impl CodecMulticodecSpec {
    /// 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/reallyme.codec.v1.CodecMulticodecSpec";
}
::buffa::impl_default_instance!(CodecMulticodecSpec);
impl ::buffa::MessageName for CodecMulticodecSpec {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecMulticodecSpec";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecMulticodecSpec";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecMulticodecSpec";
}
impl ::buffa::Message for CodecMulticodecSpec {
    /// 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.name.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.name) as u64;
        }
        if !self.code.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.code) as u64;
        }
        if !self.prefix.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.prefix) as u64;
        }
        {
            let val = self.tag.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) as u64;
            }
        }
        {
            let val = self.key_material_kind.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) as u64;
            }
        }
        if self.fixed_length != 0u32 {
            size += 1u64 + ::buffa::types::uint32_encoded_len(self.fixed_length) as u64;
        }
        if self.variable_length {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if !self.algorithm_name.is_empty() {
            size
                += 1u64
                    + ::buffa::types::string_encoded_len(&self.algorithm_name) 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.name.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.name, buf);
        }
        if !self.code.is_empty() {
            ::buffa::types::put_shared_bytes_field(2u32, &self.code, buf);
        }
        if !self.prefix.is_empty() {
            ::buffa::types::put_shared_bytes_field(3u32, &self.prefix, buf);
        }
        {
            let val = self.tag.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(4u32, val, buf);
            }
        }
        {
            let val = self.key_material_kind.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(5u32, val, buf);
            }
        }
        if self.fixed_length != 0u32 {
            ::buffa::types::put_uint32_field(6u32, self.fixed_length, buf);
        }
        if self.variable_length {
            ::buffa::types::put_bool_field(7u32, self.variable_length, buf);
        }
        if !self.algorithm_name.is_empty() {
            ::buffa::types::put_string_field(8u32, &self.algorithm_name, 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, buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_bytes(&mut self.code, buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_bytes(&mut self.prefix, buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.tag = ::buffa::EnumValue::from(::buffa::types::decode_int32(buf)?);
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.key_material_kind = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.fixed_length = ::buffa::types::decode_uint32(buf)?;
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.variable_length = ::buffa::types::decode_bool(buf)?;
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.algorithm_name, 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.code.clear();
        self.prefix.clear();
        self.tag = ::buffa::EnumValue::from(0);
        self.key_material_kind = ::buffa::EnumValue::from(0);
        self.fixed_length = 0u32;
        self.variable_length = false;
        self.algorithm_name.clear();
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecMulticodecSpec {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecMulticodecSpec";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecMulticodecSpec {
    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)]
pub const __CODEC_MULTICODEC_SPEC_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecMulticodecSpec",
    to_json: ::buffa::type_registry::any_to_json::<CodecMulticodecSpec>,
    from_json: ::buffa::type_registry::any_from_json::<CodecMulticodecSpec>,
    is_wkt: false,
};
/// CodecMulticodecLookupResult is returned when bytes are matched against the
/// supported multicodec prefix table.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecMulticodecLookupResult {
    /// Field 1: `name`
    #[serde(
        rename = "name",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub name: ::buffa::alloc::string::String,
    /// Field 2: `prefix_length`
    #[serde(
        rename = "prefixLength",
        alias = "prefix_length",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub prefix_length: u32,
    /// Field 3: `metadata`
    #[serde(
        rename = "metadata",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub metadata: ::buffa::MessageField<
        CodecMulticodecSpec,
        ::buffa::Inline<CodecMulticodecSpec>,
    >,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecMulticodecLookupResult {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecMulticodecLookupResult")
            .field("name", &self.name)
            .field("prefix_length", &self.prefix_length)
            .field("metadata", &self.metadata)
            .finish()
    }
}
impl CodecMulticodecLookupResult {
    /// 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/reallyme.codec.v1.CodecMulticodecLookupResult";
}
::buffa::impl_default_instance!(CodecMulticodecLookupResult);
impl ::buffa::MessageName for CodecMulticodecLookupResult {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecMulticodecLookupResult";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecMulticodecLookupResult";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecMulticodecLookupResult";
}
impl ::buffa::Message for CodecMulticodecLookupResult {
    /// 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.name.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.name) as u64;
        }
        if self.prefix_length != 0u32 {
            size += 1u64 + ::buffa::types::uint32_encoded_len(self.prefix_length) as u64;
        }
        if self.metadata.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.metadata.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 !self.name.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.name, buf);
        }
        if self.prefix_length != 0u32 {
            ::buffa::types::put_uint32_field(2u32, self.prefix_length, buf);
        }
        if self.metadata.is_set() {
            ::buffa::types::put_len_delimited_header(
                3u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.metadata.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(&mut self.name, buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.prefix_length = ::buffa::types::decode_uint32(buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.metadata.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.clear();
        self.prefix_length = 0u32;
        self.metadata = ::buffa::MessageField::none();
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecMulticodecLookupResult {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecMulticodecLookupResult";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecMulticodecLookupResult {
    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)]
pub const __CODEC_MULTICODEC_LOOKUP_RESULT_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecMulticodecLookupResult",
    to_json: ::buffa::type_registry::any_to_json::<CodecMulticodecLookupResult>,
    from_json: ::buffa::type_registry::any_from_json::<CodecMulticodecLookupResult>,
    is_wkt: false,
};
/// CodecMulticodecTableResult contains the supported multicodec entries.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecMulticodecTableResult {
    /// Field 1: `entries`
    #[serde(
        rename = "entries",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub entries: ::buffa::alloc::vec::Vec<CodecMulticodecSpec>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecMulticodecTableResult {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecMulticodecTableResult")
            .field("entries", &"<redacted>")
            .finish()
    }
}
impl CodecMulticodecTableResult {
    /// 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/reallyme.codec.v1.CodecMulticodecTableResult";
}
::buffa::impl_default_instance!(CodecMulticodecTableResult);
impl ::buffa::MessageName for CodecMulticodecTableResult {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecMulticodecTableResult";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecMulticodecTableResult";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecMulticodecTableResult";
}
impl ::buffa::Message for CodecMulticodecTableResult {
    /// 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.entries {
            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.entries {
            ::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.entries.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        __reallyme_zeroize_message_vec(&mut self.entries);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecMulticodecTableResult {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecMulticodecTableResult";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecMulticodecTableResult {
    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)]
pub const __CODEC_MULTICODEC_TABLE_RESULT_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecMulticodecTableResult",
    to_json: ::buffa::type_registry::any_to_json::<CodecMulticodecTableResult>,
    from_json: ::buffa::type_registry::any_from_json::<CodecMulticodecTableResult>,
    is_wkt: false,
};
/// CodecMultikeyParseResult is the binary/protobuf form of multikey parsing.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecMultikeyParseResult {
    /// Field 1: `codec_name`
    #[serde(
        rename = "codecName",
        alias = "codec_name",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub codec_name: ::buffa::alloc::string::String,
    /// Field 2: `algorithm_name`
    #[serde(
        rename = "algorithmName",
        alias = "algorithm_name",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub algorithm_name: ::buffa::alloc::string::String,
    /// Field 3: `public_key`
    #[serde(
        rename = "publicKey",
        alias = "public_key",
        serialize_with = "__reallyme_serialize_sensitive_bytes",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_bytes"
    )]
    pub public_key: ::buffa::alloc::vec::Vec<u8>,
    /// Field 4: `expected_public_key_length`
    #[serde(
        rename = "expectedPublicKeyLength",
        alias = "expected_public_key_length",
        with = "::buffa::json_helpers::uint32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_u32"
    )]
    pub expected_public_key_length: u32,
    /// Field 5: `variable_public_key_length`
    #[serde(
        rename = "variablePublicKeyLength",
        alias = "variable_public_key_length",
        with = "::buffa::json_helpers::proto_bool",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
    )]
    pub variable_public_key_length: bool,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecMultikeyParseResult {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecMultikeyParseResult")
            .field("codec_name", &self.codec_name)
            .field("algorithm_name", &self.algorithm_name)
            .field("public_key", &"<redacted>")
            .field("expected_public_key_length", &self.expected_public_key_length)
            .field("variable_public_key_length", &self.variable_public_key_length)
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecMultikeyParseResult {
    fn drop(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.public_key);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecMultikeyParseResult {}
impl<'de> ::serde::Deserialize<'de> for CodecMultikeyParseResult {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "codecName", alias = "codec_name")]
            codec_name: ::buffa::alloc::string::String,
            #[serde(rename = "algorithmName", alias = "algorithm_name")]
            algorithm_name: ::buffa::alloc::string::String,
            #[serde(rename = "publicKey", alias = "public_key", deserialize_with = "deserialize_zeroizing_bytes")]
            public_key: ::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>,
            #[serde(rename = "expectedPublicKeyLength", alias = "expected_public_key_length")]
            expected_public_key_length: u32,
            #[serde(rename = "variablePublicKeyLength", alias = "variable_public_key_length")]
            variable_public_key_length: bool,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            codec_name: ::core::mem::take(&mut wire.codec_name),
            algorithm_name: ::core::mem::take(&mut wire.algorithm_name),
            public_key: ::core::mem::take(&mut *wire.public_key),
            expected_public_key_length: ::core::mem::take(&mut wire.expected_public_key_length),
            variable_public_key_length: ::core::mem::take(&mut wire.variable_public_key_length),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecMultikeyParseResult {
    /// 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/reallyme.codec.v1.CodecMultikeyParseResult";
}
::buffa::impl_default_instance!(CodecMultikeyParseResult);
impl ::buffa::MessageName for CodecMultikeyParseResult {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecMultikeyParseResult";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecMultikeyParseResult";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecMultikeyParseResult";
}
impl ::buffa::Message for CodecMultikeyParseResult {
    /// 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.codec_name.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.codec_name) as u64;
        }
        if !self.algorithm_name.is_empty() {
            size
                += 1u64
                    + ::buffa::types::string_encoded_len(&self.algorithm_name) as u64;
        }
        if !self.public_key.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.public_key) as u64;
        }
        if self.expected_public_key_length != 0u32 {
            size
                += 1u64
                    + ::buffa::types::uint32_encoded_len(self.expected_public_key_length)
                        as u64;
        }
        if self.variable_public_key_length {
            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 !self.codec_name.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.codec_name, buf);
        }
        if !self.algorithm_name.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.algorithm_name, buf);
        }
        if !self.public_key.is_empty() {
            ::buffa::types::put_shared_bytes_field(3u32, &self.public_key, buf);
        }
        if self.expected_public_key_length != 0u32 {
            ::buffa::types::put_uint32_field(4u32, self.expected_public_key_length, buf);
        }
        if self.variable_public_key_length {
            ::buffa::types::put_bool_field(5u32, self.variable_public_key_length, 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.codec_name, buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.algorithm_name, buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::zeroize::Zeroize::zeroize(&mut self.public_key);
                ::buffa::types::merge_bytes(&mut self.public_key, buf)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.expected_public_key_length = ::buffa::types::decode_uint32(buf)?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.variable_public_key_length = ::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.codec_name.clear();
        self.algorithm_name.clear();
        ::zeroize::Zeroize::zeroize(&mut self.public_key);
        self.expected_public_key_length = 0u32;
        self.variable_public_key_length = false;
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecMultikeyParseResult {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecMultikeyParseResult";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecMultikeyParseResult {
    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)]
pub const __CODEC_MULTIKEY_PARSE_RESULT_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecMultikeyParseResult",
    to_json: ::buffa::type_registry::any_to_json::<CodecMultikeyParseResult>,
    from_json: ::buffa::type_registry::any_from_json::<CodecMultikeyParseResult>,
    is_wkt: false,
};
/// CodecDagCborVerifyCidResult contains the deterministic CID verification
/// result without requiring callers to parse fixed-shape JSON.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecDagCborVerifyCidResult {
    /// Field 1: `valid`
    #[serde(
        rename = "valid",
        with = "::buffa::json_helpers::proto_bool",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_false"
    )]
    pub valid: bool,
    /// Field 2: `expected_cid`
    #[serde(
        rename = "expectedCid",
        alias = "expected_cid",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub expected_cid: ::buffa::alloc::string::String,
    /// Field 3: `actual_cid`
    #[serde(
        rename = "actualCid",
        alias = "actual_cid",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub actual_cid: ::buffa::alloc::string::String,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecDagCborVerifyCidResult {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDagCborVerifyCidResult")
            .field("valid", &self.valid)
            .field("expected_cid", &self.expected_cid)
            .field("actual_cid", &self.actual_cid)
            .finish()
    }
}
impl CodecDagCborVerifyCidResult {
    /// 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/reallyme.codec.v1.CodecDagCborVerifyCidResult";
}
::buffa::impl_default_instance!(CodecDagCborVerifyCidResult);
impl ::buffa::MessageName for CodecDagCborVerifyCidResult {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDagCborVerifyCidResult";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDagCborVerifyCidResult";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDagCborVerifyCidResult";
}
impl ::buffa::Message for CodecDagCborVerifyCidResult {
    /// 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.valid {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if !self.expected_cid.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.expected_cid) as u64;
        }
        if !self.actual_cid.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.actual_cid) 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.valid {
            ::buffa::types::put_bool_field(1u32, self.valid, buf);
        }
        if !self.expected_cid.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.expected_cid, buf);
        }
        if !self.actual_cid.is_empty() {
            ::buffa::types::put_string_field(3u32, &self.actual_cid, 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.valid = ::buffa::types::decode_bool(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.expected_cid, buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.actual_cid, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.valid = false;
        self.expected_cid.clear();
        self.actual_cid.clear();
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecDagCborVerifyCidResult {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecDagCborVerifyCidResult";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecDagCborVerifyCidResult {
    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)]
pub const __CODEC_DAG_CBOR_VERIFY_CID_RESULT_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecDagCborVerifyCidResult",
    to_json: ::buffa::type_registry::any_to_json::<CodecDagCborVerifyCidResult>,
    from_json: ::buffa::type_registry::any_from_json::<CodecDagCborVerifyCidResult>,
    is_wkt: false,
};
/// CodecPemDecodeResult is the binary/protobuf form of PEM armor decoding.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecPemDecodeResult {
    /// Field 1: `label`
    #[serde(
        rename = "label",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub label: ::buffa::alloc::string::String,
    /// DER may contain private-key material. Receivers that request protobuf PEM
    /// decode results are responsible for copying it into their language's
    /// sensitive-buffer owner and wiping intermediate protobuf containers as soon
    /// as practical.
    ///
    /// Field 2: `der`
    #[serde(
        rename = "der",
        serialize_with = "__reallyme_serialize_sensitive_bytes",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_bytes"
    )]
    pub der: ::buffa::alloc::vec::Vec<u8>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecPemDecodeResult {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecPemDecodeResult")
            .field("label", &"<redacted>")
            .field("der", &"<redacted>")
            .finish()
    }
}
// SECURITY: Buffa's generated message contract requires Clone. Every clone
// remains an owning value, and this Drop implementation wipes its sensitive
// fields and unknown-field storage when that owner leaves scope.
impl ::core::ops::Drop for CodecPemDecodeResult {
    fn drop(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.der);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::zeroize::ZeroizeOnDrop for CodecPemDecodeResult {}
impl<'de> ::serde::Deserialize<'de> for CodecPemDecodeResult {
    fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
    where
        D: ::serde::Deserializer<'de>,
    {
        fn deserialize_zeroizing_bytes<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            __reallyme_deserialize_sensitive_bytes_zeroizing(deserializer)
        }

        fn deserialize_zeroizing_string<'de, D>(
            deserializer: D,
        ) -> ::core::result::Result<::zeroize::Zeroizing<::buffa::alloc::string::String>, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::serde::Deserialize::deserialize(deserializer).map(::zeroize::Zeroizing::new)
        }

        #[derive(Default, ::serde::Deserialize)]
        #[serde(default, deny_unknown_fields)]
        struct Wire {
            #[serde(rename = "label")]
            label: ::buffa::alloc::string::String,
            #[serde(rename = "der", deserialize_with = "deserialize_zeroizing_bytes")]
            der: ::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            label: ::core::mem::take(&mut wire.label),
            der: ::core::mem::take(&mut *wire.der),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecPemDecodeResult {
    /// 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/reallyme.codec.v1.CodecPemDecodeResult";
}
::buffa::impl_default_instance!(CodecPemDecodeResult);
impl ::buffa::MessageName for CodecPemDecodeResult {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecPemDecodeResult";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecPemDecodeResult";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecPemDecodeResult";
}
impl ::buffa::Message for CodecPemDecodeResult {
    /// 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.label.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.label) as u64;
        }
        if !self.der.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.der) 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.label.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.label, buf);
        }
        if !self.der.is_empty() {
            ::buffa::types::put_shared_bytes_field(2u32, &self.der, 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.label, buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::zeroize::Zeroize::zeroize(&mut self.der);
                ::buffa::types::merge_bytes(&mut self.der, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.label.clear();
        ::zeroize::Zeroize::zeroize(&mut self.der);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecPemDecodeResult {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecPemDecodeResult";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecPemDecodeResult {
    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)]
pub const __CODEC_PEM_DECODE_RESULT_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecPemDecodeResult",
    to_json: ::buffa::type_registry::any_to_json::<CodecPemDecodeResult>,
    from_json: ::buffa::type_registry::any_from_json::<CodecPemDecodeResult>,
    is_wkt: false,
};
/// CodecBaseEncodingError describes base64, base64url, hex, and generic byte
/// encoding failures.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecBaseEncodingError {
    /// Reason must be one of the CODEC_ERROR_REASON_BASE_* values.
    ///
    /// Field 1: `reason`
    #[serde(
        rename = "reason",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub reason: ::buffa::EnumValue<CodecErrorReason>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecBaseEncodingError {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecBaseEncodingError").field("reason", &self.reason).finish()
    }
}
impl CodecBaseEncodingError {
    /// 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/reallyme.codec.v1.CodecBaseEncodingError";
}
::buffa::impl_default_instance!(CodecBaseEncodingError);
impl ::buffa::MessageName for CodecBaseEncodingError {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecBaseEncodingError";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecBaseEncodingError";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecBaseEncodingError";
}
impl ::buffa::Message for CodecBaseEncodingError {
    /// 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;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) 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 _;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, 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.reason = ::buffa::EnumValue::from(
                    ::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.reason = ::buffa::EnumValue::from(0);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecBaseEncodingError {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecBaseEncodingError";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecBaseEncodingError {
    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)]
pub const __CODEC_BASE_ENCODING_ERROR_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecBaseEncodingError",
    to_json: ::buffa::type_registry::any_to_json::<CodecBaseEncodingError>,
    from_json: ::buffa::type_registry::any_from_json::<CodecBaseEncodingError>,
    is_wkt: false,
};
/// CodecPemError describes RFC 7468-style PEM armor boundary and body failures.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecPemError {
    /// Reason must be one of the CODEC_ERROR_REASON_PEM_* values.
    ///
    /// Field 1: `reason`
    #[serde(
        rename = "reason",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub reason: ::buffa::EnumValue<CodecErrorReason>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecPemError {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecPemError").field("reason", &self.reason).finish()
    }
}
impl CodecPemError {
    /// 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/reallyme.codec.v1.CodecPemError";
}
::buffa::impl_default_instance!(CodecPemError);
impl ::buffa::MessageName for CodecPemError {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecPemError";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecPemError";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecPemError";
}
impl ::buffa::Message for CodecPemError {
    /// 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;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) 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 _;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, 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.reason = ::buffa::EnumValue::from(
                    ::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.reason = ::buffa::EnumValue::from(0);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecPemError {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecPemError";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecPemError {
    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)]
pub const __CODEC_PEM_ERROR_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecPemError",
    to_json: ::buffa::type_registry::any_to_json::<CodecPemError>,
    from_json: ::buffa::type_registry::any_from_json::<CodecPemError>,
    is_wkt: false,
};
/// CodecMultiformatError describes multibase, multicodec, and multikey
/// envelope failures.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecMultiformatError {
    /// Reason must be one of the CODEC_ERROR_REASON_MULTIFORMAT_* values.
    ///
    /// Field 1: `reason`
    #[serde(
        rename = "reason",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub reason: ::buffa::EnumValue<CodecErrorReason>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecMultiformatError {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecMultiformatError").field("reason", &self.reason).finish()
    }
}
impl CodecMultiformatError {
    /// 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/reallyme.codec.v1.CodecMultiformatError";
}
::buffa::impl_default_instance!(CodecMultiformatError);
impl ::buffa::MessageName for CodecMultiformatError {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecMultiformatError";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecMultiformatError";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecMultiformatError";
}
impl ::buffa::Message for CodecMultiformatError {
    /// 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;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) 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 _;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, 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.reason = ::buffa::EnumValue::from(
                    ::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.reason = ::buffa::EnumValue::from(0);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecMultiformatError {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecMultiformatError";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecMultiformatError {
    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)]
pub const __CODEC_MULTIFORMAT_ERROR_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecMultiformatError",
    to_json: ::buffa::type_registry::any_to_json::<CodecMultiformatError>,
    from_json: ::buffa::type_registry::any_from_json::<CodecMultiformatError>,
    is_wkt: false,
};
/// CodecCanonicalizationError describes CBOR, DAG-CBOR, JCS, and JSON
/// canonicalization failures.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecCanonicalizationError {
    /// Reason must be one of the CODEC_ERROR_REASON_CANONICAL_* values.
    ///
    /// Field 1: `reason`
    #[serde(
        rename = "reason",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub reason: ::buffa::EnumValue<CodecErrorReason>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecCanonicalizationError {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecCanonicalizationError")
            .field("reason", &self.reason)
            .finish()
    }
}
impl CodecCanonicalizationError {
    /// 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/reallyme.codec.v1.CodecCanonicalizationError";
}
::buffa::impl_default_instance!(CodecCanonicalizationError);
impl ::buffa::MessageName for CodecCanonicalizationError {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecCanonicalizationError";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecCanonicalizationError";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecCanonicalizationError";
}
impl ::buffa::Message for CodecCanonicalizationError {
    /// 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;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) 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 _;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, 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.reason = ::buffa::EnumValue::from(
                    ::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.reason = ::buffa::EnumValue::from(0);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecCanonicalizationError {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecCanonicalizationError";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecCanonicalizationError {
    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)]
pub const __CODEC_CANONICALIZATION_ERROR_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecCanonicalizationError",
    to_json: ::buffa::type_registry::any_to_json::<CodecCanonicalizationError>,
    from_json: ::buffa::type_registry::any_from_json::<CodecCanonicalizationError>,
    is_wkt: false,
};
/// CodecBackendError describes serialization, protobuf, dispatch, FFI, WASM,
/// and internal failures that are not safe to expose as backend exception text.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecBackendError {
    /// Reason must be one of the CODEC_ERROR_REASON_BACKEND_* values.
    ///
    /// Field 1: `reason`
    #[serde(
        rename = "reason",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub reason: ::buffa::EnumValue<CodecErrorReason>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecBackendError {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecBackendError").field("reason", &self.reason).finish()
    }
}
impl CodecBackendError {
    /// 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/reallyme.codec.v1.CodecBackendError";
}
::buffa::impl_default_instance!(CodecBackendError);
impl ::buffa::MessageName for CodecBackendError {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecBackendError";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecBackendError";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecBackendError";
}
impl ::buffa::Message for CodecBackendError {
    /// 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;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) 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 _;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, 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.reason = ::buffa::EnumValue::from(
                    ::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.reason = ::buffa::EnumValue::from(0);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecBackendError {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecBackendError";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecBackendError {
    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)]
pub const __CODEC_BACKEND_ERROR_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecBackendError",
    to_json: ::buffa::type_registry::any_to_json::<CodecBackendError>,
    from_json: ::buffa::type_registry::any_from_json::<CodecBackendError>,
    is_wkt: false,
};
/// CodecBoundaryError describes malformed, oversized, or incomplete caller
/// requests. These failures are not backend failures and never contain parser
/// or runtime exception text.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecBoundaryError {
    /// Reason must be one of the CODEC_ERROR_REASON_BOUNDARY_* values.
    ///
    /// Field 1: `reason`
    #[serde(
        rename = "reason",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub reason: ::buffa::EnumValue<CodecErrorReason>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for CodecBoundaryError {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecBoundaryError").field("reason", &self.reason).finish()
    }
}
impl CodecBoundaryError {
    /// 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/reallyme.codec.v1.CodecBoundaryError";
}
::buffa::impl_default_instance!(CodecBoundaryError);
impl ::buffa::MessageName for CodecBoundaryError {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecBoundaryError";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecBoundaryError";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecBoundaryError";
}
impl ::buffa::Message for CodecBoundaryError {
    /// 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;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) 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 _;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, 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.reason = ::buffa::EnumValue::from(
                    ::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.reason = ::buffa::EnumValue::from(0);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecBoundaryError {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecBoundaryError";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecBoundaryError {
    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)]
pub const __CODEC_BOUNDARY_ERROR_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecBoundaryError",
    to_json: ::buffa::type_registry::any_to_json::<CodecBoundaryError>,
    from_json: ::buffa::type_registry::any_from_json::<CodecBoundaryError>,
    is_wkt: false,
};