reallyme-codec-proto 0.1.22

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

fn __reallyme_zeroize_unknown_fields(fields: &mut ::buffa::UnknownFields) {
    for mut field in ::core::mem::take(fields) {
        __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);
        }
        ::buffa::UnknownFieldData::Group(fields) => {
            __reallyme_zeroize_unknown_fields(fields);
        }
        ::buffa::UnknownFieldData::Varint(_)
        | ::buffa::UnknownFieldData::Fixed64(_)
        | ::buffa::UnknownFieldData::Fixed32(_) => {}
    }
}

/// CodecProtoResultStatus identifies the protobuf message carried by the
/// result-envelope payload.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
#[repr(i32)]
pub enum CodecProtoResultStatus {
    CODEC_PROTO_RESULT_STATUS_UNSPECIFIED = 0i32,
    CODEC_PROTO_RESULT_STATUS_RESULT = 1i32,
    CODEC_PROTO_RESULT_STATUS_CODEC_ERROR = 2i32,
}
impl CodecProtoResultStatus {
    ///Idiomatic alias for [`Self::CODEC_PROTO_RESULT_STATUS_UNSPECIFIED`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Unspecified: Self = Self::CODEC_PROTO_RESULT_STATUS_UNSPECIFIED;
    ///Idiomatic alias for [`Self::CODEC_PROTO_RESULT_STATUS_RESULT`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const Result: Self = Self::CODEC_PROTO_RESULT_STATUS_RESULT;
    ///Idiomatic alias for [`Self::CODEC_PROTO_RESULT_STATUS_CODEC_ERROR`]; `Debug` prints the variant name.
    #[allow(non_upper_case_globals)]
    pub const CodecError: Self = Self::CODEC_PROTO_RESULT_STATUS_CODEC_ERROR;
}
impl ::core::default::Default for CodecProtoResultStatus {
    fn default() -> Self {
        Self::CODEC_PROTO_RESULT_STATUS_UNSPECIFIED
    }
}
impl ::serde::Serialize for CodecProtoResultStatus {
    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 CodecProtoResultStatus {
    fn deserialize<D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl ::serde::de::Visitor<'_> for _V {
            type Value = CodecProtoResultStatus;
            fn expecting(
                &self,
                f: &mut ::core::fmt::Formatter<'_>,
            ) -> ::core::fmt::Result {
                f.write_str(
                    concat!(
                        "a string, integer, or null for ",
                        stringify!(CodecProtoResultStatus)
                    ),
                )
            }
            fn visit_str<E: ::serde::de::Error>(
                self,
                v: &str,
            ) -> ::core::result::Result<CodecProtoResultStatus, E> {
                <CodecProtoResultStatus 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<CodecProtoResultStatus, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom("enum value out of i32 range")
                    })?;
                <CodecProtoResultStatus 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<CodecProtoResultStatus, E> {
                let v32 = i32::try_from(v)
                    .map_err(|_| {
                        ::serde::de::Error::custom("enum value out of i32 range")
                    })?;
                <CodecProtoResultStatus 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<CodecProtoResultStatus, E> {
                ::core::result::Result::Ok(::core::default::Default::default())
            }
        }
        d.deserialize_any(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for CodecProtoResultStatus {
    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 CodecProtoResultStatus {
    fn from_i32(value: i32) -> ::core::option::Option<Self> {
        match value {
            0i32 => {
                ::core::option::Option::Some(Self::CODEC_PROTO_RESULT_STATUS_UNSPECIFIED)
            }
            1i32 => ::core::option::Option::Some(Self::CODEC_PROTO_RESULT_STATUS_RESULT),
            2i32 => {
                ::core::option::Option::Some(Self::CODEC_PROTO_RESULT_STATUS_CODEC_ERROR)
            }
            _ => ::core::option::Option::None,
        }
    }
    fn to_i32(&self) -> i32 {
        *self as i32
    }
    fn proto_name(&self) -> &'static str {
        match self {
            Self::CODEC_PROTO_RESULT_STATUS_UNSPECIFIED => {
                "CODEC_PROTO_RESULT_STATUS_UNSPECIFIED"
            }
            Self::CODEC_PROTO_RESULT_STATUS_RESULT => "CODEC_PROTO_RESULT_STATUS_RESULT",
            Self::CODEC_PROTO_RESULT_STATUS_CODEC_ERROR => {
                "CODEC_PROTO_RESULT_STATUS_CODEC_ERROR"
            }
        }
    }
    fn from_proto_name(name: &str) -> ::core::option::Option<Self> {
        match name {
            "CODEC_PROTO_RESULT_STATUS_UNSPECIFIED" => {
                ::core::option::Option::Some(Self::CODEC_PROTO_RESULT_STATUS_UNSPECIFIED)
            }
            "CODEC_PROTO_RESULT_STATUS_RESULT" => {
                ::core::option::Option::Some(Self::CODEC_PROTO_RESULT_STATUS_RESULT)
            }
            "CODEC_PROTO_RESULT_STATUS_CODEC_ERROR" => {
                ::core::option::Option::Some(Self::CODEC_PROTO_RESULT_STATUS_CODEC_ERROR)
            }
            _ => ::core::option::Option::None,
        }
    }
    fn values() -> &'static [Self] {
        &[
            Self::CODEC_PROTO_RESULT_STATUS_UNSPECIFIED,
            Self::CODEC_PROTO_RESULT_STATUS_RESULT,
            Self::CODEC_PROTO_RESULT_STATUS_CODEC_ERROR,
        ]
    }
}
/// CodecPemLabel is the typed protobuf representation of the PEM labels accepted
/// by the codec parser.
#[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,
        ]
    }
}
/// 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.
#[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.
#[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
#[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,
    /// 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,
    /// 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_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_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)
            }
            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)
            }
            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_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_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_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_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_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_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,
        ]
    }
}
/// 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.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecError {
    #[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("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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        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
                        += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
                __buffa::oneof::codec_error::Error::Pem(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
                __buffa::oneof::codec_error::Error::Multiformat(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
                __buffa::oneof::codec_error::Error::Canonicalization(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
                __buffa::oneof::codec_error::Error::Backend(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
                __buffa::oneof::codec_error::Error::Boundary(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[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,
                        __cache.consume_next(),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_error::Error::Pem(x) => {
                    ::buffa::types::put_len_delimited_header(
                        2u32,
                        __cache.consume_next(),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_error::Error::Multiformat(x) => {
                    ::buffa::types::put_len_delimited_header(
                        3u32,
                        __cache.consume_next(),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_error::Error::Canonicalization(x) => {
                    ::buffa::types::put_len_delimited_header(
                        4u32,
                        __cache.consume_next(),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_error::Error::Backend(x) => {
                    ::buffa::types::put_len_delimited_header(
                        5u32,
                        __cache.consume_next(),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_error::Error::Boundary(x) => {
                    ::buffa::types::put_len_delimited_header(
                        6u32,
                        __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_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),
                        ),
                    );
                }
            }
            _ => {
                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;
        __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 __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() {
                        "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();
                __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;
}
/// CodecProtoResultEnvelope is the single binary response shape for executable
/// protobuf and generated ProtoJSON requests.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default, deny_unknown_fields)]
pub struct CodecProtoResultEnvelope {
    /// Field 1: `status`
    #[serde(
        rename = "status",
        with = "::buffa::json_helpers::proto_enum",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_default_enum_value"
    )]
    pub status: ::buffa::EnumValue<CodecProtoResultStatus>,
    /// Field 2: `payload`
    #[serde(
        rename = "payload",
        with = "::buffa::json_helpers::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 CodecProtoResultEnvelope {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecProtoResultEnvelope")
            .field("status", &self.status)
            .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 CodecProtoResultEnvelope {
    fn drop(&mut self) {
        ::zeroize::Zeroize::zeroize(&mut self.payload);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl<'de> ::serde::Deserialize<'de> for CodecProtoResultEnvelope {
    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>,
        {
            ::buffa::json_helpers::bytes::deserialize(deserializer)
                .map(::zeroize::Zeroizing::new)
        }

        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 = "status", with = "::buffa::json_helpers::proto_enum")]
            status: ::buffa::EnumValue<CodecProtoResultStatus>,
            #[serde(rename = "payload", deserialize_with = "deserialize_zeroizing_bytes")]
            payload: ::zeroize::Zeroizing<::buffa::alloc::vec::Vec<u8>>,
        }

        let mut wire = Wire::deserialize(deserializer)?;
        Ok(Self {
            status: wire.status,
            payload: ::core::mem::take(&mut *wire.payload),
            __buffa_unknown_fields: Default::default(),
        })
    }
}
impl CodecProtoResultEnvelope {
    /// 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.CodecProtoResultEnvelope";
}
::buffa::impl_default_instance!(CodecProtoResultEnvelope);
impl ::buffa::MessageName for CodecProtoResultEnvelope {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecProtoResultEnvelope";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecProtoResultEnvelope";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecProtoResultEnvelope";
}
impl ::buffa::Message for CodecProtoResultEnvelope {
    /// Returns the total encoded size in bytes.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        {
            let val = self.status.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if !self.payload.is_empty() {
            size += 1u32 + ::buffa::types::bytes_encoded_len(&self.payload) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        {
            let val = self.status.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, buf);
            }
        }
        if !self.payload.is_empty() {
            ::buffa::types::put_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::Varint,
                )?;
                self.status = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(buf)?,
                );
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::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.status = ::buffa::EnumValue::from(0);
        ::zeroize::Zeroize::zeroize(&mut self.payload);
        __reallyme_zeroize_unknown_fields(&mut self.__buffa_unknown_fields);
    }
}
impl ::buffa::ExtensionSet for CodecProtoResultEnvelope {
    const PROTO_FQN: &'static str = "reallyme.codec.v1.CodecProtoResultEnvelope";
    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 CodecProtoResultEnvelope {
    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_PROTO_RESULT_ENVELOPE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/reallyme.codec.v1.CodecProtoResultEnvelope",
    to_json: ::buffa::type_registry::any_to_json::<CodecProtoResultEnvelope>,
    from_json: ::buffa::type_registry::any_from_json::<CodecProtoResultEnvelope>,
    is_wkt: false,
};
#[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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        if !self.name.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[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",
        with = "::buffa::json_helpers::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<'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>,
        {
            ::buffa::json_helpers::bytes::deserialize(deserializer)
                .map(::zeroize::Zeroizing::new)
        }

        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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        if !self.value.is_empty() {
            size += 1u32 + ::buffa::types::bytes_encoded_len(&self.value) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.value.is_empty() {
            ::buffa::types::put_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,
                )?;
                ::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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[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<'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>,
        {
            ::buffa::json_helpers::bytes::deserialize(deserializer)
                .map(::zeroize::Zeroizing::new)
        }

        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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        if !self.multikey.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.multikey) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[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,
                )?;
                ::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",
        with = "::buffa::json_helpers::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<'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>,
        {
            ::buffa::json_helpers::bytes::deserialize(deserializer)
                .map(::zeroize::Zeroizing::new)
        }

        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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        if !self.cid.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.cid) as u32;
        }
        if !self.payload.is_empty() {
            size += 1u32 + ::buffa::types::bytes_encoded_len(&self.payload) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[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_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,
                )?;
                ::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,
};
/// Zero limits select the audited codec defaults. An empty allowed-label list
/// selects the default PRIVATE KEY, EC PRIVATE KEY, and PUBLIC KEY set.
#[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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        if !self.allowed_labels.is_empty() {
            let payload: u32 = self
                .allowed_labels
                .iter()
                .map(|v| ::buffa::types::int32_encoded_len(v.to_i32()) as u32)
                .sum::<u32>();
            size
                += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32 + payload;
        }
        if self.max_input_len != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.max_input_len) as u32;
        }
        if self.max_der_len != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.max_der_len) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.allowed_labels.is_empty() {
            let payload: u32 = self
                .allowed_labels
                .iter()
                .map(|v| ::buffa::types::int32_encoded_len(v.to_i32()) as u32)
                .sum::<u32>();
            ::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(&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",
        with = "::buffa::json_helpers::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>,
    #[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", &self.options)
            .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<'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>,
        {
            ::buffa::json_helpers::bytes::deserialize(deserializer)
                .map(::zeroize::Zeroizing::new)
        }

        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>,
        }

        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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        if !self.pem.is_empty() {
            size += 1u32 + ::buffa::types::bytes_encoded_len(&self.pem) as u32;
        }
        if self.options.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.options.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.pem.is_empty() {
            ::buffa::types::put_bytes_field(1u32, &self.pem, buf);
        }
        if self.options.is_set() {
            ::buffa::types::put_len_delimited_header(2u32, __cache.consume_next(), buf);
            self.options.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_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,
};
/// 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", &self.operation)
            .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 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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        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
                        += 2u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
                __buffa::oneof::codec_operation_request::Operation::MulticodecLookupPrefix(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
                __buffa::oneof::codec_operation_request::Operation::MulticodecTable(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
                __buffa::oneof::codec_operation_request::Operation::MultikeyParse(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
                __buffa::oneof::codec_operation_request::Operation::DagCborVerifyCid(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
                __buffa::oneof::codec_operation_request::Operation::PemDecode(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[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,
                        __cache.consume_next(),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_request::Operation::MulticodecLookupPrefix(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1001u32,
                        __cache.consume_next(),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_request::Operation::MulticodecTable(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1002u32,
                        __cache.consume_next(),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_request::Operation::MultikeyParse(x) => {
                    ::buffa::types::put_len_delimited_header(
                        2000u32,
                        __cache.consume_next(),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_request::Operation::DagCborVerifyCid(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        3000u32,
                        __cache.consume_next(),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::codec_operation_request::Operation::PemDecode(x) => {
                    ::buffa::types::put_len_delimited_header(
                        4000u32,
                        __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),
                        ),
                    );
                }
            }
            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),
                        ),
                    );
                }
            }
            _ => {
                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),
                                    ),
                                );
                            }
                        }
                        "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),
                                    ),
                                );
                            }
                        }
                        _ => {
                            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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        if !self.name.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
        }
        if !self.code.is_empty() {
            size += 1u32 + ::buffa::types::bytes_encoded_len(&self.code) as u32;
        }
        if !self.prefix.is_empty() {
            size += 1u32 + ::buffa::types::bytes_encoded_len(&self.prefix) as u32;
        }
        {
            let val = self.tag.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        {
            let val = self.key_material_kind.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        if self.fixed_length != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.fixed_length) as u32;
        }
        if self.variable_length {
            size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
        }
        if !self.algorithm_name.is_empty() {
            size
                += 1u32
                    + ::buffa::types::string_encoded_len(&self.algorithm_name) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[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_bytes_field(2u32, &self.code, buf);
        }
        if !self.prefix.is_empty() {
            ::buffa::types::put_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>,
    #[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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        if !self.name.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
        }
        if self.prefix_length != 0u32 {
            size += 1u32 + ::buffa::types::uint32_encoded_len(self.prefix_length) as u32;
        }
        if self.metadata.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.metadata.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[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, __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", &self.entries)
            .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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        for v in &self.entries {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for v in &self.entries {
            ::buffa::types::put_len_delimited_header(1u32, __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();
                ::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) {
        self.entries.clear();
        __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",
        with = "::buffa::json_helpers::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<'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>,
        {
            ::buffa::json_helpers::bytes::deserialize(deserializer)
                .map(::zeroize::Zeroizing::new)
        }

        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: wire.expected_public_key_length,
            variable_public_key_length: 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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        if !self.codec_name.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.codec_name) as u32;
        }
        if !self.algorithm_name.is_empty() {
            size
                += 1u32
                    + ::buffa::types::string_encoded_len(&self.algorithm_name) as u32;
        }
        if !self.public_key.is_empty() {
            size += 1u32 + ::buffa::types::bytes_encoded_len(&self.public_key) as u32;
        }
        if self.expected_public_key_length != 0u32 {
            size
                += 1u32
                    + ::buffa::types::uint32_encoded_len(self.expected_public_key_length)
                        as u32;
        }
        if self.variable_public_key_length {
            size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[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_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,
                )?;
                ::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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        if self.valid {
            size += 1u32 + ::buffa::types::BOOL_ENCODED_LEN as u32;
        }
        if !self.expected_cid.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.expected_cid) as u32;
        }
        if !self.actual_cid.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.actual_cid) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[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",
        with = "::buffa::json_helpers::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", &self.label)
            .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<'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>,
        {
            ::buffa::json_helpers::bytes::deserialize(deserializer)
                .map(::zeroize::Zeroizing::new)
        }

        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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        if !self.label.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.label) as u32;
        }
        if !self.der.is_empty() {
            size += 1u32 + ::buffa::types::bytes_encoded_len(&self.der) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[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_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,
                )?;
                ::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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[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.
    ///
    /// The result is a `u32`; the protobuf specification requires all
    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
    /// compliant message will never overflow this type.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u32;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u32 + ::buffa::types::int32_encoded_len(val) as u32;
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[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,
};