reallyme-codec-proto 0.3.1

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

#[derive(Clone, Debug, Default)]
pub struct CodecErrorView<'a> {
    /// Error origin is explicit so SDKs never infer caller-versus-provider
    /// attribution from branch-specific numeric reason ranges. Missing, unknown,
    /// or inconsistent origin values must fail closed as provider failures.
    ///
    /// Field 100: `origin`
    pub origin: ::buffa::EnumValue<super::super::CodecErrorOrigin>,
    pub error: ::core::option::Option<
        super::super::__buffa::view::oneof::codec_error::Error<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::buffa::MessageView<'a> for CodecErrorView<'a> {
    type Owned = super::super::CodecError;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            100u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.origin = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(&mut cur)?,
                );
            }
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_error::Error::BaseEncoding(
                        ref mut existing,
                    ),
                ) = view.error
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.error = Some(
                        super::super::__buffa::view::oneof::codec_error::Error::BaseEncoding(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecBaseEncodingErrorView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_error::Error::Pem(
                        ref mut existing,
                    ),
                ) = view.error
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.error = Some(
                        super::super::__buffa::view::oneof::codec_error::Error::Pem(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecPemErrorView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_error::Error::Multiformat(
                        ref mut existing,
                    ),
                ) = view.error
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.error = Some(
                        super::super::__buffa::view::oneof::codec_error::Error::Multiformat(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecMultiformatErrorView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_error::Error::Canonicalization(
                        ref mut existing,
                    ),
                ) = view.error
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.error = Some(
                        super::super::__buffa::view::oneof::codec_error::Error::Canonicalization(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecCanonicalizationErrorView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_error::Error::Backend(
                        ref mut existing,
                    ),
                ) = view.error
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.error = Some(
                        super::super::__buffa::view::oneof::codec_error::Error::Backend(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecBackendErrorView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_error::Error::Boundary(
                        ref mut existing,
                    ),
                ) = view.error
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.error = Some(
                        super::super::__buffa::view::oneof::codec_error::Error::Boundary(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecBoundaryErrorView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<super::super::CodecError, ::buffa::DecodeError> {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<super::super::CodecError, ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecError {
            origin: self.origin,
            error: match self.error.as_ref() {
                ::core::option::Option::Some(v) => {
                    ::core::option::Option::Some(
                        match v {
                            super::super::__buffa::view::oneof::codec_error::Error::BaseEncoding(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_error::Error::BaseEncoding(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_error::Error::Pem(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_error::Error::Pem(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_error::Error::Multiformat(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_error::Error::Multiformat(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_error::Error::Canonicalization(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_error::Error::Canonicalization(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_error::Error::Backend(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_error::Error::Backend(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_error::Error::Boundary(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_error::Error::Boundary(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                        },
                    )
                }
                ::core::option::Option::None => ::core::option::Option::None,
            },
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecErrorView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if let ::core::option::Option::Some(ref v) = self.error {
            match v {
                super::super::__buffa::view::oneof::codec_error::Error::BaseEncoding(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_error::Error::Pem(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_error::Error::Multiformat(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_error::Error::Canonicalization(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_error::Error::Backend(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_error::Error::Boundary(x) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
            }
        }
        {
            let val = self.origin.to_i32();
            if val != 0 {
                size += 2u64 + ::buffa::types::int32_encoded_len(val) as u64;
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref v) = self.error {
            match v {
                super::super::__buffa::view::oneof::codec_error::Error::BaseEncoding(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_error::Error::Pem(x) => {
                    ::buffa::types::put_len_delimited_header(
                        2u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_error::Error::Multiformat(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        3u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_error::Error::Canonicalization(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        4u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_error::Error::Backend(x) => {
                    ::buffa::types::put_len_delimited_header(
                        5u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_error::Error::Boundary(x) => {
                    ::buffa::types::put_len_delimited_header(
                        6u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
            }
        }
        {
            let val = self.origin.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(100u32, val, buf);
            }
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecErrorView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.origin) {
            __map.serialize_entry("origin", &self.origin)?;
        }
        if let ::core::option::Option::Some(ref __ov) = self.error {
            match __ov {
                super::super::__buffa::view::oneof::codec_error::Error::BaseEncoding(
                    v,
                ) => {
                    __map.serialize_entry("baseEncoding", v)?;
                }
                super::super::__buffa::view::oneof::codec_error::Error::Pem(v) => {
                    __map.serialize_entry("pem", v)?;
                }
                super::super::__buffa::view::oneof::codec_error::Error::Multiformat(
                    v,
                ) => {
                    __map.serialize_entry("multiformat", v)?;
                }
                super::super::__buffa::view::oneof::codec_error::Error::Canonicalization(
                    v,
                ) => {
                    __map.serialize_entry("canonicalization", v)?;
                }
                super::super::__buffa::view::oneof::codec_error::Error::Backend(v) => {
                    __map.serialize_entry("backend", v)?;
                }
                super::super::__buffa::view::oneof::codec_error::Error::Boundary(v) => {
                    __map.serialize_entry("boundary", v)?;
                }
            }
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecErrorView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecErrorView);
::buffa::impl_view_reborrow!(CodecErrorView);
/** Self-contained, `'static` owned view of a `CodecError` message.

 Wraps [`::buffa::OwnedView`]`<`[`CodecErrorView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CodecErrorView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct CodecErrorOwnedView(::buffa::OwnedView<CodecErrorView<'static>>);
impl CodecErrorOwnedView {
    /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
    ///
    /// The view borrows directly from the buffer's data; the buffer is
    /// retained inside the returned handle.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
    /// protobuf data.
    pub fn decode(
        bytes: ::buffa::bytes::Bytes,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecErrorOwnedView(::buffa::OwnedView::decode(bytes)?),
        )
    }
    /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
    /// max message size).
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
    /// exceeds the configured limits.
    pub fn decode_with_options(
        bytes: ::buffa::bytes::Bytes,
        opts: &::buffa::DecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecErrorOwnedView(::buffa::OwnedView::decode_with_options(bytes, opts)?),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError::MessageTooLarge`] if the
    /// message's encoded size exceeds the 2 GiB protobuf limit, or
    /// another [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::CodecError,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecErrorOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`CodecErrorView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &CodecErrorView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    ///
    /// Infallible: this type's constructors wire-decode their
    /// buffer, and a view produced by wire decoding always
    /// converts. Delegates to [`::buffa::OwnedView::to_owned_message`],
    /// whose contract also governs handles converted from a raw
    /// [`::buffa::OwnedView`].
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::CodecError {
        self.0.to_owned_message()
    }
    /// The underlying bytes buffer.
    #[must_use]
    pub fn bytes(&self) -> &::buffa::bytes::Bytes {
        self.0.bytes()
    }
    /// Consume the handle, returning the underlying bytes buffer.
    #[must_use]
    pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
        self.0.into_bytes()
    }
    /// Error origin is explicit so SDKs never infer caller-versus-provider
    /// attribution from branch-specific numeric reason ranges. Missing, unknown,
    /// or inconsistent origin values must fail closed as provider failures.
    ///
    /// Field 100: `origin`
    #[must_use]
    pub fn origin(&self) -> ::buffa::EnumValue<super::super::CodecErrorOrigin> {
        self.0.reborrow().origin
    }
    /// Oneof `error`.
    #[must_use]
    pub fn error(
        &self,
    ) -> ::core::option::Option<
        &super::super::__buffa::view::oneof::codec_error::Error<'_>,
    > {
        self.0.reborrow().error.as_ref()
    }
}
impl ::core::convert::From<::buffa::OwnedView<CodecErrorView<'static>>>
for CodecErrorOwnedView {
    fn from(inner: ::buffa::OwnedView<CodecErrorView<'static>>) -> Self {
        CodecErrorOwnedView(inner)
    }
}
impl ::core::convert::From<CodecErrorOwnedView>
for ::buffa::OwnedView<CodecErrorView<'static>> {
    fn from(wrapper: CodecErrorOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<CodecErrorView<'static>>>
for CodecErrorOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<CodecErrorView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::CodecError {
    type View<'a> = CodecErrorView<'a>;
    type ViewHandle = CodecErrorOwnedView;
}
impl ::serde::Serialize for CodecErrorOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
#[derive(Clone, Debug, Default)]
pub struct CodecMulticodecPrefixForNameRequestView<'a> {
    /// Field 1: `name`
    pub name: &'a str,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::buffa::MessageView<'a> for CodecMulticodecPrefixForNameRequestView<'a> {
    type Owned = super::super::CodecMulticodecPrefixForNameRequest;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.name = ::buffa::types::borrow_str(&mut cur)?;
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecMulticodecPrefixForNameRequest,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecMulticodecPrefixForNameRequest,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecMulticodecPrefixForNameRequest {
            name: self.name.to_string(),
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecMulticodecPrefixForNameRequestView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.name.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.name) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.name.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.name, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecMulticodecPrefixForNameRequestView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_empty_str(self.name) {
            __map.serialize_entry("name", self.name)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecMulticodecPrefixForNameRequestView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecMulticodecPrefixForNameRequestView);
::buffa::impl_view_reborrow!(CodecMulticodecPrefixForNameRequestView);
/** Self-contained, `'static` owned view of a `CodecMulticodecPrefixForNameRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`CodecMulticodecPrefixForNameRequestView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CodecMulticodecPrefixForNameRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct CodecMulticodecPrefixForNameRequestOwnedView(
    ::buffa::OwnedView<CodecMulticodecPrefixForNameRequestView<'static>>,
);
impl CodecMulticodecPrefixForNameRequestOwnedView {
    /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
    ///
    /// The view borrows directly from the buffer's data; the buffer is
    /// retained inside the returned handle.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
    /// protobuf data.
    pub fn decode(
        bytes: ::buffa::bytes::Bytes,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecMulticodecPrefixForNameRequestOwnedView(
                ::buffa::OwnedView::decode(bytes)?,
            ),
        )
    }
    /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
    /// max message size).
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
    /// exceeds the configured limits.
    pub fn decode_with_options(
        bytes: ::buffa::bytes::Bytes,
        opts: &::buffa::DecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecMulticodecPrefixForNameRequestOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError::MessageTooLarge`] if the
    /// message's encoded size exceeds the 2 GiB protobuf limit, or
    /// another [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::CodecMulticodecPrefixForNameRequest,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecMulticodecPrefixForNameRequestOwnedView(
                ::buffa::OwnedView::from_owned(msg)?,
            ),
        )
    }
    /// Borrow the full [`CodecMulticodecPrefixForNameRequestView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &CodecMulticodecPrefixForNameRequestView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    ///
    /// Infallible: this type's constructors wire-decode their
    /// buffer, and a view produced by wire decoding always
    /// converts. Delegates to [`::buffa::OwnedView::to_owned_message`],
    /// whose contract also governs handles converted from a raw
    /// [`::buffa::OwnedView`].
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::CodecMulticodecPrefixForNameRequest {
        self.0.to_owned_message()
    }
    /// The underlying bytes buffer.
    #[must_use]
    pub fn bytes(&self) -> &::buffa::bytes::Bytes {
        self.0.bytes()
    }
    /// Consume the handle, returning the underlying bytes buffer.
    #[must_use]
    pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
        self.0.into_bytes()
    }
    /// Field 1: `name`
    #[must_use]
    pub fn name(&self) -> &'_ str {
        self.0.reborrow().name
    }
}
impl ::core::convert::From<
    ::buffa::OwnedView<CodecMulticodecPrefixForNameRequestView<'static>>,
> for CodecMulticodecPrefixForNameRequestOwnedView {
    fn from(
        inner: ::buffa::OwnedView<CodecMulticodecPrefixForNameRequestView<'static>>,
    ) -> Self {
        CodecMulticodecPrefixForNameRequestOwnedView(inner)
    }
}
impl ::core::convert::From<CodecMulticodecPrefixForNameRequestOwnedView>
for ::buffa::OwnedView<CodecMulticodecPrefixForNameRequestView<'static>> {
    fn from(wrapper: CodecMulticodecPrefixForNameRequestOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<
    ::buffa::OwnedView<CodecMulticodecPrefixForNameRequestView<'static>>,
> for CodecMulticodecPrefixForNameRequestOwnedView {
    fn as_ref(
        &self,
    ) -> &::buffa::OwnedView<CodecMulticodecPrefixForNameRequestView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::CodecMulticodecPrefixForNameRequest {
    type View<'a> = CodecMulticodecPrefixForNameRequestView<'a>;
    type ViewHandle = CodecMulticodecPrefixForNameRequestOwnedView;
}
impl ::serde::Serialize for CodecMulticodecPrefixForNameRequestOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
#[derive(Clone, Default)]
pub struct CodecMulticodecLookupPrefixRequestView<'a> {
    /// Field 1: `value`
    pub value: &'a [u8],
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecMulticodecLookupPrefixRequestView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecMulticodecLookupPrefixRequestView")
            .field("value", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecMulticodecLookupPrefixRequestView<'a> {
    type Owned = super::super::CodecMulticodecLookupPrefixRequest;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.value = ::buffa::types::borrow_bytes(&mut cur)?;
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecMulticodecLookupPrefixRequest,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecMulticodecLookupPrefixRequest,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecMulticodecLookupPrefixRequest {
            value: (self.value).to_vec(),
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecMulticodecLookupPrefixRequestView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.value.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.value) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.value.is_empty() {
            ::buffa::types::put_shared_bytes_field(1u32, &self.value, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecMulticodecLookupPrefixRequestView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_empty_bytes(self.value) {
            __map
                .serialize_entry(
                    "value",
                    &super::super::__ReallyMeSensitiveBytes(self.value),
                )?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecMulticodecLookupPrefixRequestView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecMulticodecLookupPrefixRequestView);
::buffa::impl_view_reborrow!(CodecMulticodecLookupPrefixRequestView);
#[derive(Clone, Debug, Default)]
pub struct CodecMulticodecTableRequestView<'a> {
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::buffa::MessageView<'a> for CodecMulticodecTableRequestView<'a> {
    type Owned = super::super::CodecMulticodecTableRequest;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecMulticodecTableRequest,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecMulticodecTableRequest,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecMulticodecTableRequest {
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecMulticodecTableRequestView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecMulticodecTableRequestView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecMulticodecTableRequestView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecMulticodecTableRequestView);
::buffa::impl_view_reborrow!(CodecMulticodecTableRequestView);
/** Self-contained, `'static` owned view of a `CodecMulticodecTableRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`CodecMulticodecTableRequestView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CodecMulticodecTableRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct CodecMulticodecTableRequestOwnedView(
    ::buffa::OwnedView<CodecMulticodecTableRequestView<'static>>,
);
impl CodecMulticodecTableRequestOwnedView {
    /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
    ///
    /// The view borrows directly from the buffer's data; the buffer is
    /// retained inside the returned handle.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
    /// protobuf data.
    pub fn decode(
        bytes: ::buffa::bytes::Bytes,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecMulticodecTableRequestOwnedView(::buffa::OwnedView::decode(bytes)?),
        )
    }
    /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
    /// max message size).
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
    /// exceeds the configured limits.
    pub fn decode_with_options(
        bytes: ::buffa::bytes::Bytes,
        opts: &::buffa::DecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecMulticodecTableRequestOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError::MessageTooLarge`] if the
    /// message's encoded size exceeds the 2 GiB protobuf limit, or
    /// another [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::CodecMulticodecTableRequest,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecMulticodecTableRequestOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`CodecMulticodecTableRequestView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &CodecMulticodecTableRequestView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    ///
    /// Infallible: this type's constructors wire-decode their
    /// buffer, and a view produced by wire decoding always
    /// converts. Delegates to [`::buffa::OwnedView::to_owned_message`],
    /// whose contract also governs handles converted from a raw
    /// [`::buffa::OwnedView`].
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::CodecMulticodecTableRequest {
        self.0.to_owned_message()
    }
    /// The underlying bytes buffer.
    #[must_use]
    pub fn bytes(&self) -> &::buffa::bytes::Bytes {
        self.0.bytes()
    }
    /// Consume the handle, returning the underlying bytes buffer.
    #[must_use]
    pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
        self.0.into_bytes()
    }
}
impl ::core::convert::From<::buffa::OwnedView<CodecMulticodecTableRequestView<'static>>>
for CodecMulticodecTableRequestOwnedView {
    fn from(
        inner: ::buffa::OwnedView<CodecMulticodecTableRequestView<'static>>,
    ) -> Self {
        CodecMulticodecTableRequestOwnedView(inner)
    }
}
impl ::core::convert::From<CodecMulticodecTableRequestOwnedView>
for ::buffa::OwnedView<CodecMulticodecTableRequestView<'static>> {
    fn from(wrapper: CodecMulticodecTableRequestOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<CodecMulticodecTableRequestView<'static>>>
for CodecMulticodecTableRequestOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<CodecMulticodecTableRequestView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::CodecMulticodecTableRequest {
    type View<'a> = CodecMulticodecTableRequestView<'a>;
    type ViewHandle = CodecMulticodecTableRequestOwnedView;
}
impl ::serde::Serialize for CodecMulticodecTableRequestOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
#[derive(Clone, Default)]
pub struct CodecMultikeyParseRequestView<'a> {
    /// Field 1: `multikey`
    pub multikey: &'a str,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecMultikeyParseRequestView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecMultikeyParseRequestView")
            .field("multikey", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecMultikeyParseRequestView<'a> {
    type Owned = super::super::CodecMultikeyParseRequest;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.multikey = ::buffa::types::borrow_str(&mut cur)?;
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecMultikeyParseRequest,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecMultikeyParseRequest,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecMultikeyParseRequest {
            multikey: self.multikey.to_string(),
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecMultikeyParseRequestView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.multikey.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.multikey) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.multikey.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.multikey, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecMultikeyParseRequestView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_empty_str(self.multikey) {
            __map.serialize_entry("multikey", self.multikey)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecMultikeyParseRequestView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecMultikeyParseRequestView);
::buffa::impl_view_reborrow!(CodecMultikeyParseRequestView);
#[derive(Clone, Default)]
pub struct CodecDagCborVerifyCidRequestView<'a> {
    /// Field 1: `cid`
    pub cid: &'a str,
    /// Field 2: `payload`
    pub payload: &'a [u8],
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDagCborVerifyCidRequestView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDagCborVerifyCidRequestView")
            .field("cid", &self.cid)
            .field("payload", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDagCborVerifyCidRequestView<'a> {
    type Owned = super::super::CodecDagCborVerifyCidRequest;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.cid = ::buffa::types::borrow_str(&mut cur)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.payload = ::buffa::types::borrow_bytes(&mut cur)?;
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDagCborVerifyCidRequest,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDagCborVerifyCidRequest,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDagCborVerifyCidRequest {
            cid: self.cid.to_string(),
            payload: (self.payload).to_vec(),
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDagCborVerifyCidRequestView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.cid.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.cid) as u64;
        }
        if !self.payload.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.payload) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.cid.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.cid, buf);
        }
        if !self.payload.is_empty() {
            ::buffa::types::put_shared_bytes_field(2u32, &self.payload, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDagCborVerifyCidRequestView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_empty_str(self.cid) {
            __map.serialize_entry("cid", self.cid)?;
        }
        if !::buffa::json_helpers::skip_if::is_empty_bytes(self.payload) {
            __map
                .serialize_entry(
                    "payload",
                    &super::super::__ReallyMeSensitiveBytes(self.payload),
                )?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDagCborVerifyCidRequestView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecDagCborVerifyCidRequestView);
::buffa::impl_view_reborrow!(CodecDagCborVerifyCidRequestView);
/// CodecDagCborEncodeRequest is the typed recursive DAG-CBOR encode contract.
/// DAG-CBOR map keys are restricted to text keys by
/// the adapter even though the reusable recursive value schema can represent
/// the wider deterministic-CBOR key domain.
#[derive(Clone, Default)]
pub struct CodecDagCborEncodeRequestView<'a> {
    /// Field 1: `value`
    pub value: ::buffa::MessageFieldView<
        super::super::__buffa::view::CodecDeterministicCborValueView<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDagCborEncodeRequestView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDagCborEncodeRequestView")
            .field("value", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDagCborEncodeRequestView<'a> {
    type Owned = super::super::CodecDagCborEncodeRequest;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                match view.value.as_mut() {
                    Some(existing) => {
                        ::buffa::MessageView::merge_into_view(existing, sub, __sub_ctx)?
                    }
                    None => {
                        view.value = ::buffa::MessageFieldView::set(
                            <super::super::__buffa::view::CodecDeterministicCborValueView as ::buffa::MessageView>::decode_view_ctx(
                                sub,
                                __sub_ctx,
                            )?,
                        );
                    }
                }
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDagCborEncodeRequest,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDagCborEncodeRequest,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDagCborEncodeRequest {
            value: match self.value.as_option() {
                Some(v) => {
                    ::buffa::MessageField::<
                        super::super::CodecDeterministicCborValue,
                        ::buffa::Inline<super::super::CodecDeterministicCborValue>,
                    >::some(v.to_owned_from_source(__buffa_src)?)
                }
                None => ::buffa::MessageField::none(),
            },
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDagCborEncodeRequestView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if self.value.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.value.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.value.is_set() {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.value.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDagCborEncodeRequestView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        {
            if let ::core::option::Option::Some(__v) = self.value.as_option() {
                __map.serialize_entry("value", __v)?;
            }
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDagCborEncodeRequestView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDagCborEncodeRequest";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDagCborEncodeRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDagCborEncodeRequest";
}
::buffa::impl_default_view_instance!(CodecDagCborEncodeRequestView);
::buffa::impl_view_reborrow!(CodecDagCborEncodeRequestView);
#[derive(Clone, Default)]
pub struct CodecDagCborEncodeResultView<'a> {
    /// Encoded DAG-CBOR bytes may contain the complete sensitive document.
    ///
    /// Field 1: `encoded`
    pub encoded: &'a [u8],
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDagCborEncodeResultView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDagCborEncodeResultView")
            .field("encoded", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDagCborEncodeResultView<'a> {
    type Owned = super::super::CodecDagCborEncodeResult;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.encoded = ::buffa::types::borrow_bytes(&mut cur)?;
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDagCborEncodeResult,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDagCborEncodeResult,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDagCborEncodeResult {
            encoded: (self.encoded).to_vec(),
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDagCborEncodeResultView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.encoded.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.encoded) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.encoded.is_empty() {
            ::buffa::types::put_shared_bytes_field(1u32, &self.encoded, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDagCborEncodeResultView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_empty_bytes(self.encoded) {
            __map
                .serialize_entry(
                    "encoded",
                    &super::super::__ReallyMeSensitiveBytes(self.encoded),
                )?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDagCborEncodeResultView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDagCborEncodeResult";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDagCborEncodeResult";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDagCborEncodeResult";
}
::buffa::impl_default_view_instance!(CodecDagCborEncodeResultView);
::buffa::impl_view_reborrow!(CodecDagCborEncodeResultView);
#[derive(Clone, Default)]
pub struct CodecDagCborDecodeRequestView<'a> {
    /// Encoded DAG-CBOR bytes may contain the complete sensitive document.
    ///
    /// Field 1: `encoded`
    pub encoded: &'a [u8],
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDagCborDecodeRequestView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDagCborDecodeRequestView")
            .field("encoded", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDagCborDecodeRequestView<'a> {
    type Owned = super::super::CodecDagCborDecodeRequest;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.encoded = ::buffa::types::borrow_bytes(&mut cur)?;
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDagCborDecodeRequest,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDagCborDecodeRequest,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDagCborDecodeRequest {
            encoded: (self.encoded).to_vec(),
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDagCborDecodeRequestView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.encoded.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.encoded) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.encoded.is_empty() {
            ::buffa::types::put_shared_bytes_field(1u32, &self.encoded, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDagCborDecodeRequestView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_empty_bytes(self.encoded) {
            __map
                .serialize_entry(
                    "encoded",
                    &super::super::__ReallyMeSensitiveBytes(self.encoded),
                )?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDagCborDecodeRequestView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDagCborDecodeRequest";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDagCborDecodeRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDagCborDecodeRequest";
}
::buffa::impl_default_view_instance!(CodecDagCborDecodeRequestView);
::buffa::impl_view_reborrow!(CodecDagCborDecodeRequestView);
#[derive(Clone, Default)]
pub struct CodecDagCborDecodeResultView<'a> {
    /// Field 1: `value`
    pub value: ::buffa::MessageFieldView<
        super::super::__buffa::view::CodecDeterministicCborValueView<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDagCborDecodeResultView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDagCborDecodeResultView")
            .field("value", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDagCborDecodeResultView<'a> {
    type Owned = super::super::CodecDagCborDecodeResult;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                match view.value.as_mut() {
                    Some(existing) => {
                        ::buffa::MessageView::merge_into_view(existing, sub, __sub_ctx)?
                    }
                    None => {
                        view.value = ::buffa::MessageFieldView::set(
                            <super::super::__buffa::view::CodecDeterministicCborValueView as ::buffa::MessageView>::decode_view_ctx(
                                sub,
                                __sub_ctx,
                            )?,
                        );
                    }
                }
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDagCborDecodeResult,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDagCborDecodeResult,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDagCborDecodeResult {
            value: match self.value.as_option() {
                Some(v) => {
                    ::buffa::MessageField::<
                        super::super::CodecDeterministicCborValue,
                        ::buffa::Inline<super::super::CodecDeterministicCborValue>,
                    >::some(v.to_owned_from_source(__buffa_src)?)
                }
                None => ::buffa::MessageField::none(),
            },
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDagCborDecodeResultView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if self.value.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.value.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.value.is_set() {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.value.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDagCborDecodeResultView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        {
            if let ::core::option::Option::Some(__v) = self.value.as_option() {
                __map.serialize_entry("value", __v)?;
            }
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDagCborDecodeResultView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDagCborDecodeResult";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDagCborDecodeResult";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDagCborDecodeResult";
}
::buffa::impl_default_view_instance!(CodecDagCborDecodeResultView);
::buffa::impl_view_reborrow!(CodecDagCborDecodeResultView);
/// Zero limits select the documented codec defaults. An empty allowed-label list
/// selects PUBLIC KEY only; private-key labels require an explicit allowlist.
#[derive(Clone, Debug, Default)]
pub struct CodecPemDecodeOptionsView<'a> {
    /// Field 1: `allowed_labels`
    pub allowed_labels: ::buffa::RepeatedView<
        'a,
        ::buffa::EnumValue<super::super::CodecPemLabel>,
    >,
    /// Field 2: `max_input_len`
    pub max_input_len: u32,
    /// Field 3: `max_der_len`
    pub max_der_len: u32,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::buffa::MessageView<'a> for CodecPemDecodeOptionsView<'a> {
    type Owned = super::super::CodecPemDecodeOptions;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.max_input_len = ::buffa::types::decode_uint32(&mut cur)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.max_der_len = ::buffa::types::decode_uint32(&mut cur)?;
            }
            1u32 => {
                if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
                    let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                    view.allowed_labels
                        .reserve(::buffa::encoding::count_varints(payload));
                    let mut pcur: &[u8] = payload;
                    while !pcur.is_empty() {
                        view.allowed_labels
                            .push(
                                ::buffa::EnumValue::from(
                                    ::buffa::types::decode_int32_packed(&mut pcur)?,
                                ),
                            );
                    }
                } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
                    view.allowed_labels
                        .push(
                            ::buffa::EnumValue::from(
                                ::buffa::types::decode_int32(&mut cur)?,
                            ),
                        );
                } else {
                    return Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecPemDecodeOptions,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecPemDecodeOptions,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecPemDecodeOptions {
            allowed_labels: self.allowed_labels.to_vec(),
            max_input_len: self.max_input_len,
            max_der_len: self.max_der_len,
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecPemDecodeOptionsView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.allowed_labels.is_empty() {
            let payload: u64 = self
                .allowed_labels
                .iter()
                .map(|v| ::buffa::types::int32_encoded_len(v.to_i32()) as u64)
                .sum::<u64>();
            size += 1u64 + ::buffa::encoding::varint_len(payload) as u64 + payload;
        }
        if self.max_input_len != 0u32 {
            size += 1u64 + ::buffa::types::uint32_encoded_len(self.max_input_len) as u64;
        }
        if self.max_der_len != 0u32 {
            size += 1u64 + ::buffa::types::uint32_encoded_len(self.max_der_len) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.allowed_labels.is_empty() {
            let payload: u64 = self
                .allowed_labels
                .iter()
                .map(|v| ::buffa::types::int32_encoded_len(v.to_i32()) as u64)
                .sum::<u64>();
            ::buffa::types::put_len_delimited_header(1u32, payload, buf);
            for v in &self.allowed_labels {
                ::buffa::types::encode_int32(v.to_i32(), buf);
            }
        }
        if self.max_input_len != 0u32 {
            ::buffa::types::put_uint32_field(2u32, self.max_input_len, buf);
        }
        if self.max_der_len != 0u32 {
            ::buffa::types::put_uint32_field(3u32, self.max_der_len, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecPemDecodeOptionsView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !self.allowed_labels.is_empty() {
            __map
                .serialize_entry(
                    "allowedLabels",
                    &::buffa::json_helpers::EnumSeqJson(&self.allowed_labels),
                )?;
        }
        if !::buffa::json_helpers::skip_if::is_zero_u32(&self.max_input_len) {
            __map
                .serialize_entry(
                    "maxInputLen",
                    &::buffa::json_helpers::ProtoJson(&self.max_input_len),
                )?;
        }
        if !::buffa::json_helpers::skip_if::is_zero_u32(&self.max_der_len) {
            __map
                .serialize_entry(
                    "maxDerLen",
                    &::buffa::json_helpers::ProtoJson(&self.max_der_len),
                )?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecPemDecodeOptionsView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecPemDecodeOptionsView);
::buffa::impl_view_reborrow!(CodecPemDecodeOptionsView);
/** Self-contained, `'static` owned view of a `CodecPemDecodeOptions` message.

 Wraps [`::buffa::OwnedView`]`<`[`CodecPemDecodeOptionsView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CodecPemDecodeOptionsView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct CodecPemDecodeOptionsOwnedView(
    ::buffa::OwnedView<CodecPemDecodeOptionsView<'static>>,
);
impl CodecPemDecodeOptionsOwnedView {
    /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
    ///
    /// The view borrows directly from the buffer's data; the buffer is
    /// retained inside the returned handle.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
    /// protobuf data.
    pub fn decode(
        bytes: ::buffa::bytes::Bytes,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecPemDecodeOptionsOwnedView(::buffa::OwnedView::decode(bytes)?),
        )
    }
    /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
    /// max message size).
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
    /// exceeds the configured limits.
    pub fn decode_with_options(
        bytes: ::buffa::bytes::Bytes,
        opts: &::buffa::DecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecPemDecodeOptionsOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError::MessageTooLarge`] if the
    /// message's encoded size exceeds the 2 GiB protobuf limit, or
    /// another [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::CodecPemDecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecPemDecodeOptionsOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`CodecPemDecodeOptionsView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &CodecPemDecodeOptionsView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    ///
    /// Infallible: this type's constructors wire-decode their
    /// buffer, and a view produced by wire decoding always
    /// converts. Delegates to [`::buffa::OwnedView::to_owned_message`],
    /// whose contract also governs handles converted from a raw
    /// [`::buffa::OwnedView`].
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::CodecPemDecodeOptions {
        self.0.to_owned_message()
    }
    /// The underlying bytes buffer.
    #[must_use]
    pub fn bytes(&self) -> &::buffa::bytes::Bytes {
        self.0.bytes()
    }
    /// Consume the handle, returning the underlying bytes buffer.
    #[must_use]
    pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
        self.0.into_bytes()
    }
    /// Field 1: `allowed_labels`
    #[must_use]
    pub fn allowed_labels(
        &self,
    ) -> &::buffa::RepeatedView<'_, ::buffa::EnumValue<super::super::CodecPemLabel>> {
        &self.0.reborrow().allowed_labels
    }
    /// Field 2: `max_input_len`
    #[must_use]
    pub fn max_input_len(&self) -> u32 {
        self.0.reborrow().max_input_len
    }
    /// Field 3: `max_der_len`
    #[must_use]
    pub fn max_der_len(&self) -> u32 {
        self.0.reborrow().max_der_len
    }
}
impl ::core::convert::From<::buffa::OwnedView<CodecPemDecodeOptionsView<'static>>>
for CodecPemDecodeOptionsOwnedView {
    fn from(inner: ::buffa::OwnedView<CodecPemDecodeOptionsView<'static>>) -> Self {
        CodecPemDecodeOptionsOwnedView(inner)
    }
}
impl ::core::convert::From<CodecPemDecodeOptionsOwnedView>
for ::buffa::OwnedView<CodecPemDecodeOptionsView<'static>> {
    fn from(wrapper: CodecPemDecodeOptionsOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<CodecPemDecodeOptionsView<'static>>>
for CodecPemDecodeOptionsOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<CodecPemDecodeOptionsView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::CodecPemDecodeOptions {
    type View<'a> = CodecPemDecodeOptionsView<'a>;
    type ViewHandle = CodecPemDecodeOptionsOwnedView;
}
impl ::serde::Serialize for CodecPemDecodeOptionsOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
#[derive(Clone, Default)]
pub struct CodecPemDecodeRequestView<'a> {
    /// 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`
    pub pem: &'a [u8],
    /// Field 2: `options`
    pub options: ::buffa::MessageFieldView<
        super::super::__buffa::view::CodecPemDecodeOptionsView<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecPemDecodeRequestView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecPemDecodeRequestView")
            .field("pem", &"<redacted>")
            .field("options", &self.options)
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecPemDecodeRequestView<'a> {
    type Owned = super::super::CodecPemDecodeRequest;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.pem = ::buffa::types::borrow_bytes(&mut cur)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                match view.options.as_mut() {
                    Some(existing) => {
                        ::buffa::MessageView::merge_into_view(existing, sub, __sub_ctx)?
                    }
                    None => {
                        view.options = ::buffa::MessageFieldView::set(
                            <super::super::__buffa::view::CodecPemDecodeOptionsView as ::buffa::MessageView>::decode_view_ctx(
                                sub,
                                __sub_ctx,
                            )?,
                        );
                    }
                }
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecPemDecodeRequest,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecPemDecodeRequest,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecPemDecodeRequest {
            pem: (self.pem).to_vec(),
            options: match self.options.as_option() {
                Some(v) => {
                    ::buffa::MessageField::<
                        super::super::CodecPemDecodeOptions,
                        ::buffa::Inline<super::super::CodecPemDecodeOptions>,
                    >::some(v.to_owned_from_source(__buffa_src)?)
                }
                None => ::buffa::MessageField::none(),
            },
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecPemDecodeRequestView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.pem.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.pem) as u64;
        }
        if self.options.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.options.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.pem.is_empty() {
            ::buffa::types::put_shared_bytes_field(1u32, &self.pem, buf);
        }
        if self.options.is_set() {
            ::buffa::types::put_len_delimited_header(
                2u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.options.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecPemDecodeRequestView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_empty_bytes(self.pem) {
            __map.serialize_entry("pem", &super::super::__ReallyMeSensitiveBytes(self.pem))?;
        }
        {
            if let ::core::option::Option::Some(__v) = self.options.as_option() {
                __map.serialize_entry("options", __v)?;
            }
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecPemDecodeRequestView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecPemDecodeRequestView);
::buffa::impl_view_reborrow!(CodecPemDecodeRequestView);
/// Zero values select the documented codec defaults.
#[derive(Clone, Debug, Default)]
pub struct CodecPemEncodeOptionsView<'a> {
    /// Field 1: `max_der_len`
    pub max_der_len: u32,
    /// Field 2: `line_width`
    pub line_width: u32,
    /// Field 3: `line_ending`
    pub line_ending: ::buffa::EnumValue<super::super::CodecPemLineEnding>,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::buffa::MessageView<'a> for CodecPemEncodeOptionsView<'a> {
    type Owned = super::super::CodecPemEncodeOptions;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.max_der_len = ::buffa::types::decode_uint32(&mut cur)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.line_width = ::buffa::types::decode_uint32(&mut cur)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.line_ending = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(&mut cur)?,
                );
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecPemEncodeOptions,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecPemEncodeOptions,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecPemEncodeOptions {
            max_der_len: self.max_der_len,
            line_width: self.line_width,
            line_ending: self.line_ending,
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecPemEncodeOptionsView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if self.max_der_len != 0u32 {
            size += 1u64 + ::buffa::types::uint32_encoded_len(self.max_der_len) as u64;
        }
        if self.line_width != 0u32 {
            size += 1u64 + ::buffa::types::uint32_encoded_len(self.line_width) as u64;
        }
        {
            let val = self.line_ending.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) as u64;
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.max_der_len != 0u32 {
            ::buffa::types::put_uint32_field(1u32, self.max_der_len, buf);
        }
        if self.line_width != 0u32 {
            ::buffa::types::put_uint32_field(2u32, self.line_width, buf);
        }
        {
            let val = self.line_ending.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(3u32, val, buf);
            }
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecPemEncodeOptionsView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_zero_u32(&self.max_der_len) {
            __map
                .serialize_entry(
                    "maxDerLen",
                    &::buffa::json_helpers::ProtoJson(&self.max_der_len),
                )?;
        }
        if !::buffa::json_helpers::skip_if::is_zero_u32(&self.line_width) {
            __map
                .serialize_entry(
                    "lineWidth",
                    &::buffa::json_helpers::ProtoJson(&self.line_width),
                )?;
        }
        if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.line_ending) {
            __map.serialize_entry("lineEnding", &self.line_ending)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecPemEncodeOptionsView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecPemEncodeOptions";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecPemEncodeOptions";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecPemEncodeOptions";
}
::buffa::impl_default_view_instance!(CodecPemEncodeOptionsView);
::buffa::impl_view_reborrow!(CodecPemEncodeOptionsView);
/** Self-contained, `'static` owned view of a `CodecPemEncodeOptions` message.

 Wraps [`::buffa::OwnedView`]`<`[`CodecPemEncodeOptionsView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CodecPemEncodeOptionsView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct CodecPemEncodeOptionsOwnedView(
    ::buffa::OwnedView<CodecPemEncodeOptionsView<'static>>,
);
impl CodecPemEncodeOptionsOwnedView {
    /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
    ///
    /// The view borrows directly from the buffer's data; the buffer is
    /// retained inside the returned handle.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
    /// protobuf data.
    pub fn decode(
        bytes: ::buffa::bytes::Bytes,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecPemEncodeOptionsOwnedView(::buffa::OwnedView::decode(bytes)?),
        )
    }
    /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
    /// max message size).
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
    /// exceeds the configured limits.
    pub fn decode_with_options(
        bytes: ::buffa::bytes::Bytes,
        opts: &::buffa::DecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecPemEncodeOptionsOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError::MessageTooLarge`] if the
    /// message's encoded size exceeds the 2 GiB protobuf limit, or
    /// another [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::CodecPemEncodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecPemEncodeOptionsOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`CodecPemEncodeOptionsView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &CodecPemEncodeOptionsView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    ///
    /// Infallible: this type's constructors wire-decode their
    /// buffer, and a view produced by wire decoding always
    /// converts. Delegates to [`::buffa::OwnedView::to_owned_message`],
    /// whose contract also governs handles converted from a raw
    /// [`::buffa::OwnedView`].
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::CodecPemEncodeOptions {
        self.0.to_owned_message()
    }
    /// The underlying bytes buffer.
    #[must_use]
    pub fn bytes(&self) -> &::buffa::bytes::Bytes {
        self.0.bytes()
    }
    /// Consume the handle, returning the underlying bytes buffer.
    #[must_use]
    pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
        self.0.into_bytes()
    }
    /// Field 1: `max_der_len`
    #[must_use]
    pub fn max_der_len(&self) -> u32 {
        self.0.reborrow().max_der_len
    }
    /// Field 2: `line_width`
    #[must_use]
    pub fn line_width(&self) -> u32 {
        self.0.reborrow().line_width
    }
    /// Field 3: `line_ending`
    #[must_use]
    pub fn line_ending(&self) -> ::buffa::EnumValue<super::super::CodecPemLineEnding> {
        self.0.reborrow().line_ending
    }
}
impl ::core::convert::From<::buffa::OwnedView<CodecPemEncodeOptionsView<'static>>>
for CodecPemEncodeOptionsOwnedView {
    fn from(inner: ::buffa::OwnedView<CodecPemEncodeOptionsView<'static>>) -> Self {
        CodecPemEncodeOptionsOwnedView(inner)
    }
}
impl ::core::convert::From<CodecPemEncodeOptionsOwnedView>
for ::buffa::OwnedView<CodecPemEncodeOptionsView<'static>> {
    fn from(wrapper: CodecPemEncodeOptionsOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<CodecPemEncodeOptionsView<'static>>>
for CodecPemEncodeOptionsOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<CodecPemEncodeOptionsView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::CodecPemEncodeOptions {
    type View<'a> = CodecPemEncodeOptionsView<'a>;
    type ViewHandle = CodecPemEncodeOptionsOwnedView;
}
impl ::serde::Serialize for CodecPemEncodeOptionsOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
#[derive(Clone, Default)]
pub struct CodecPemEncodeRequestView<'a> {
    /// Field 1: `label`
    pub label: ::buffa::EnumValue<super::super::CodecPemLabel>,
    /// DER may contain private-key material. Generated owned-message drop wipes
    /// the retained field; transport decoders may create temporary copies that
    /// cannot be reliably wiped. Use binary requests for secret-bearing DER.
    ///
    /// Field 2: `der`
    pub der: &'a [u8],
    /// Field 3: `options`
    pub options: ::buffa::MessageFieldView<
        super::super::__buffa::view::CodecPemEncodeOptionsView<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecPemEncodeRequestView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecPemEncodeRequestView")
            .field("label", &"<redacted>")
            .field("der", &"<redacted>")
            .field("options", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecPemEncodeRequestView<'a> {
    type Owned = super::super::CodecPemEncodeRequest;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.label = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(&mut cur)?,
                );
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.der = ::buffa::types::borrow_bytes(&mut cur)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                match view.options.as_mut() {
                    Some(existing) => {
                        ::buffa::MessageView::merge_into_view(existing, sub, __sub_ctx)?
                    }
                    None => {
                        view.options = ::buffa::MessageFieldView::set(
                            <super::super::__buffa::view::CodecPemEncodeOptionsView as ::buffa::MessageView>::decode_view_ctx(
                                sub,
                                __sub_ctx,
                            )?,
                        );
                    }
                }
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecPemEncodeRequest,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecPemEncodeRequest,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecPemEncodeRequest {
            label: self.label,
            der: (self.der).to_vec(),
            options: match self.options.as_option() {
                Some(v) => {
                    ::buffa::MessageField::<
                        super::super::CodecPemEncodeOptions,
                        ::buffa::Inline<super::super::CodecPemEncodeOptions>,
                    >::some(v.to_owned_from_source(__buffa_src)?)
                }
                None => ::buffa::MessageField::none(),
            },
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecPemEncodeRequestView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        {
            let val = self.label.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) as u64;
            }
        }
        if !self.der.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.der) as u64;
        }
        if self.options.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.options.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        {
            let val = self.label.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, buf);
            }
        }
        if !self.der.is_empty() {
            ::buffa::types::put_shared_bytes_field(2u32, &self.der, buf);
        }
        if self.options.is_set() {
            ::buffa::types::put_len_delimited_header(
                3u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.options.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecPemEncodeRequestView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.label) {
            __map.serialize_entry("label", &self.label)?;
        }
        if !::buffa::json_helpers::skip_if::is_empty_bytes(self.der) {
            __map.serialize_entry("der", &super::super::__ReallyMeSensitiveBytes(self.der))?;
        }
        {
            if let ::core::option::Option::Some(__v) = self.options.as_option() {
                __map.serialize_entry("options", __v)?;
            }
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecPemEncodeRequestView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecPemEncodeRequest";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecPemEncodeRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecPemEncodeRequest";
}
::buffa::impl_default_view_instance!(CodecPemEncodeRequestView);
::buffa::impl_view_reborrow!(CodecPemEncodeRequestView);
#[derive(Clone, Default)]
pub struct CodecPemEncodeResultView<'a> {
    /// PEM armor may contain private-key material and remains byte-oriented so
    /// SDK callers can promptly wipe the returned owner.
    ///
    /// Field 1: `pem`
    pub pem: &'a [u8],
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecPemEncodeResultView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecPemEncodeResultView")
            .field("pem", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecPemEncodeResultView<'a> {
    type Owned = super::super::CodecPemEncodeResult;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.pem = ::buffa::types::borrow_bytes(&mut cur)?;
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecPemEncodeResult,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecPemEncodeResult,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecPemEncodeResult {
            pem: (self.pem).to_vec(),
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecPemEncodeResultView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.pem.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.pem) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.pem.is_empty() {
            ::buffa::types::put_shared_bytes_field(1u32, &self.pem, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecPemEncodeResultView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_empty_bytes(self.pem) {
            __map.serialize_entry("pem", &super::super::__ReallyMeSensitiveBytes(self.pem))?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecPemEncodeResultView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecPemEncodeResult";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecPemEncodeResult";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecPemEncodeResult";
}
::buffa::impl_default_view_instance!(CodecPemEncodeResultView);
::buffa::impl_view_reborrow!(CodecPemEncodeResultView);
/// CodecDeterministicCborNull is the explicit null branch for the deterministic
/// generic-CBOR value union.
#[derive(Clone, Default)]
pub struct CodecDeterministicCborNullView<'a> {
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDeterministicCborNullView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborNullView")

            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDeterministicCborNullView<'a> {
    type Owned = super::super::CodecDeterministicCborNull;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborNull,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborNull,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDeterministicCborNull {
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDeterministicCborNullView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDeterministicCborNullView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDeterministicCborNullView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborNull";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborNull";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborNull";
}
::buffa::impl_default_view_instance!(CodecDeterministicCborNullView);
::buffa::impl_view_reborrow!(CodecDeterministicCborNullView);
#[derive(Clone, Default)]
pub struct CodecDeterministicCborBoolView<'a> {
    /// Field 1: `value`
    pub value: bool,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDeterministicCborBoolView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborBoolView")
            .field("value", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDeterministicCborBoolView<'a> {
    type Owned = super::super::CodecDeterministicCborBool;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.value = ::buffa::types::decode_bool(&mut cur)?;
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborBool,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborBool,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDeterministicCborBool {
            value: self.value,
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDeterministicCborBoolView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if self.value {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.value {
            ::buffa::types::put_bool_field(1u32, self.value, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDeterministicCborBoolView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if self.value {
            __map.serialize_entry("value", &self.value)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDeterministicCborBoolView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborBool";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborBool";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborBool";
}
::buffa::impl_default_view_instance!(CodecDeterministicCborBoolView);
::buffa::impl_view_reborrow!(CodecDeterministicCborBoolView);
#[derive(Clone, Default)]
pub struct CodecDeterministicCborUnsignedIntegerView<'a> {
    /// Field 1: `value`
    pub value: u64,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDeterministicCborUnsignedIntegerView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborUnsignedIntegerView")
            .field("value", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDeterministicCborUnsignedIntegerView<'a> {
    type Owned = super::super::CodecDeterministicCborUnsignedInteger;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.value = ::buffa::types::decode_uint64(&mut cur)?;
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborUnsignedInteger,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborUnsignedInteger,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDeterministicCborUnsignedInteger {
            value: self.value,
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDeterministicCborUnsignedIntegerView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if self.value != 0u64 {
            size += 1u64 + ::buffa::types::uint64_encoded_len(self.value) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.value != 0u64 {
            ::buffa::types::put_uint64_field(1u32, self.value, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDeterministicCborUnsignedIntegerView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_zero_u64(&self.value) {
            __map
                .serialize_entry(
                    "value",
                    &::buffa::json_helpers::ProtoJson(&self.value),
                )?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDeterministicCborUnsignedIntegerView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborUnsignedInteger";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborUnsignedInteger";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborUnsignedInteger";
}
::buffa::impl_default_view_instance!(CodecDeterministicCborUnsignedIntegerView);
::buffa::impl_view_reborrow!(CodecDeterministicCborUnsignedIntegerView);
#[derive(Clone, Default)]
pub struct CodecDeterministicCborNegativeIntegerView<'a> {
    /// Field 1: `value`
    pub value: i64,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDeterministicCborNegativeIntegerView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborNegativeIntegerView")
            .field("value", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDeterministicCborNegativeIntegerView<'a> {
    type Owned = super::super::CodecDeterministicCborNegativeInteger;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.value = ::buffa::types::decode_sint64(&mut cur)?;
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborNegativeInteger,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborNegativeInteger,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDeterministicCborNegativeInteger {
            value: self.value,
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDeterministicCborNegativeIntegerView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if self.value != 0i64 {
            size += 1u64 + ::buffa::types::sint64_encoded_len(self.value) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.value != 0i64 {
            ::buffa::types::put_sint64_field(1u32, self.value, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDeterministicCborNegativeIntegerView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_zero_i64(&self.value) {
            __map
                .serialize_entry(
                    "value",
                    &::buffa::json_helpers::ProtoJson(&self.value),
                )?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDeterministicCborNegativeIntegerView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborNegativeInteger";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborNegativeInteger";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborNegativeInteger";
}
::buffa::impl_default_view_instance!(CodecDeterministicCborNegativeIntegerView);
::buffa::impl_view_reborrow!(CodecDeterministicCborNegativeIntegerView);
/// CodecDeterministicCborInteger is the exact integer representation supported
/// by deterministic generic CBOR. Negative values are restricted to
/// i64::MIN..=-1; zero and positive values must use unsigned_value.
#[derive(Clone, Default)]
pub struct CodecDeterministicCborIntegerView<'a> {
    pub value: ::core::option::Option<
        super::super::__buffa::view::oneof::codec_deterministic_cbor_integer::Value<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDeterministicCborIntegerView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborIntegerView")
            .field("value", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDeterministicCborIntegerView<'a> {
    type Owned = super::super::CodecDeterministicCborInteger;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_deterministic_cbor_integer::Value::UnsignedValue(
                        ref mut existing,
                    ),
                ) = view.value
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.value = Some(
                        super::super::__buffa::view::oneof::codec_deterministic_cbor_integer::Value::UnsignedValue(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDeterministicCborUnsignedIntegerView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_deterministic_cbor_integer::Value::NegativeValue(
                        ref mut existing,
                    ),
                ) = view.value
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.value = Some(
                        super::super::__buffa::view::oneof::codec_deterministic_cbor_integer::Value::NegativeValue(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDeterministicCborNegativeIntegerView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborInteger,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborInteger,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDeterministicCborInteger {
            value: match self.value.as_ref() {
                ::core::option::Option::Some(v) => {
                    ::core::option::Option::Some(
                        match v {
                            super::super::__buffa::view::oneof::codec_deterministic_cbor_integer::Value::UnsignedValue(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_deterministic_cbor_integer::Value::UnsignedValue(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_deterministic_cbor_integer::Value::NegativeValue(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_deterministic_cbor_integer::Value::NegativeValue(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                        },
                    )
                }
                ::core::option::Option::None => ::core::option::Option::None,
            },
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDeterministicCborIntegerView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if let ::core::option::Option::Some(ref v) = self.value {
            match v {
                super::super::__buffa::view::oneof::codec_deterministic_cbor_integer::Value::UnsignedValue(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_integer::Value::NegativeValue(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref v) = self.value {
            match v {
                super::super::__buffa::view::oneof::codec_deterministic_cbor_integer::Value::UnsignedValue(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_integer::Value::NegativeValue(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        2u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
            }
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDeterministicCborIntegerView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if let ::core::option::Option::Some(ref __ov) = self.value {
            match __ov {
                super::super::__buffa::view::oneof::codec_deterministic_cbor_integer::Value::UnsignedValue(
                    v,
                ) => {
                    __map.serialize_entry("unsignedValue", v)?;
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_integer::Value::NegativeValue(
                    v,
                ) => {
                    __map.serialize_entry("negativeValue", v)?;
                }
            }
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDeterministicCborIntegerView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborInteger";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborInteger";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborInteger";
}
::buffa::impl_default_view_instance!(CodecDeterministicCborIntegerView);
::buffa::impl_view_reborrow!(CodecDeterministicCborIntegerView);
#[derive(Clone, Default)]
pub struct CodecDeterministicCborTextView<'a> {
    /// Field 1: `value`
    pub value: &'a str,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDeterministicCborTextView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborTextView")
            .field("value", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDeterministicCborTextView<'a> {
    type Owned = super::super::CodecDeterministicCborText;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.value = ::buffa::types::borrow_str(&mut cur)?;
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborText,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborText,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDeterministicCborText {
            value: self.value.to_string(),
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDeterministicCborTextView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.value.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.value) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.value.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.value, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDeterministicCborTextView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_empty_str(self.value) {
            __map.serialize_entry("value", self.value)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDeterministicCborTextView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborText";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborText";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborText";
}
::buffa::impl_default_view_instance!(CodecDeterministicCborTextView);
::buffa::impl_view_reborrow!(CodecDeterministicCborTextView);
#[derive(Clone, Default)]
pub struct CodecDeterministicCborBytesView<'a> {
    /// Field 1: `value`
    pub value: &'a [u8],
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDeterministicCborBytesView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborBytesView")
            .field("value", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDeterministicCborBytesView<'a> {
    type Owned = super::super::CodecDeterministicCborBytes;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.value = ::buffa::types::borrow_bytes(&mut cur)?;
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborBytes,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborBytes,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDeterministicCborBytes {
            value: (self.value).to_vec(),
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDeterministicCborBytesView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.value.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.value) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.value.is_empty() {
            ::buffa::types::put_shared_bytes_field(1u32, &self.value, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDeterministicCborBytesView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_empty_bytes(self.value) {
            __map
                .serialize_entry(
                    "value",
                    &super::super::__ReallyMeSensitiveBytes(self.value),
                )?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDeterministicCborBytesView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborBytes";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborBytes";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborBytes";
}
::buffa::impl_default_view_instance!(CodecDeterministicCborBytesView);
::buffa::impl_view_reborrow!(CodecDeterministicCborBytesView);
/// CodecDeterministicCborMapKey is the closed map-key domain for deterministic
/// generic CBOR. Protobuf map\<\> is intentionally not used because it cannot
/// preserve mixed key types or duplicate entries for semantic rejection.
#[derive(Clone, Default)]
pub struct CodecDeterministicCborMapKeyView<'a> {
    pub key: ::core::option::Option<
        super::super::__buffa::view::oneof::codec_deterministic_cbor_map_key::Key<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDeterministicCborMapKeyView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborMapKeyView")
            .field("key", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDeterministicCborMapKeyView<'a> {
    type Owned = super::super::CodecDeterministicCborMapKey;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_deterministic_cbor_map_key::Key::IntegerKey(
                        ref mut existing,
                    ),
                ) = view.key
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.key = Some(
                        super::super::__buffa::view::oneof::codec_deterministic_cbor_map_key::Key::IntegerKey(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDeterministicCborIntegerView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_deterministic_cbor_map_key::Key::TextKey(
                        ref mut existing,
                    ),
                ) = view.key
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.key = Some(
                        super::super::__buffa::view::oneof::codec_deterministic_cbor_map_key::Key::TextKey(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDeterministicCborTextView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborMapKey,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborMapKey,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDeterministicCborMapKey {
            key: match self.key.as_ref() {
                ::core::option::Option::Some(v) => {
                    ::core::option::Option::Some(
                        match v {
                            super::super::__buffa::view::oneof::codec_deterministic_cbor_map_key::Key::IntegerKey(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_deterministic_cbor_map_key::Key::IntegerKey(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_deterministic_cbor_map_key::Key::TextKey(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_deterministic_cbor_map_key::Key::TextKey(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                        },
                    )
                }
                ::core::option::Option::None => ::core::option::Option::None,
            },
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDeterministicCborMapKeyView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if let ::core::option::Option::Some(ref v) = self.key {
            match v {
                super::super::__buffa::view::oneof::codec_deterministic_cbor_map_key::Key::IntegerKey(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_map_key::Key::TextKey(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref v) = self.key {
            match v {
                super::super::__buffa::view::oneof::codec_deterministic_cbor_map_key::Key::IntegerKey(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_map_key::Key::TextKey(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        2u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
            }
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDeterministicCborMapKeyView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if let ::core::option::Option::Some(ref __ov) = self.key {
            match __ov {
                super::super::__buffa::view::oneof::codec_deterministic_cbor_map_key::Key::IntegerKey(
                    v,
                ) => {
                    __map.serialize_entry("integerKey", v)?;
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_map_key::Key::TextKey(
                    v,
                ) => {
                    __map.serialize_entry("textKey", v)?;
                }
            }
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDeterministicCborMapKeyView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborMapKey";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborMapKey";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborMapKey";
}
::buffa::impl_default_view_instance!(CodecDeterministicCborMapKeyView);
::buffa::impl_view_reborrow!(CodecDeterministicCborMapKeyView);
#[derive(Clone, Default)]
pub struct CodecDeterministicCborMapEntryView<'a> {
    /// Field 1: `key`
    pub key: ::buffa::MessageFieldView<
        super::super::__buffa::view::CodecDeterministicCborMapKeyView<'a>,
    >,
    /// Field 2: `value`
    pub value: ::buffa::MessageFieldView<
        super::super::__buffa::view::CodecDeterministicCborValueView<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDeterministicCborMapEntryView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborMapEntryView")
            .field("key", &"<redacted>")
            .field("value", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDeterministicCborMapEntryView<'a> {
    type Owned = super::super::CodecDeterministicCborMapEntry;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                match view.key.as_mut() {
                    Some(existing) => {
                        ::buffa::MessageView::merge_into_view(existing, sub, __sub_ctx)?
                    }
                    None => {
                        view.key = ::buffa::MessageFieldView::set(
                            <super::super::__buffa::view::CodecDeterministicCborMapKeyView as ::buffa::MessageView>::decode_view_ctx(
                                sub,
                                __sub_ctx,
                            )?,
                        );
                    }
                }
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                match view.value.as_mut() {
                    Some(existing) => {
                        ::buffa::MessageView::merge_into_view(existing, sub, __sub_ctx)?
                    }
                    None => {
                        view.value = ::buffa::MessageFieldView::set(
                            <super::super::__buffa::view::CodecDeterministicCborValueView as ::buffa::MessageView>::decode_view_ctx(
                                sub,
                                __sub_ctx,
                            )?,
                        );
                    }
                }
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborMapEntry,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborMapEntry,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDeterministicCborMapEntry {
            key: match self.key.as_option() {
                Some(v) => {
                    ::buffa::MessageField::<
                        super::super::CodecDeterministicCborMapKey,
                        ::buffa::Inline<super::super::CodecDeterministicCborMapKey>,
                    >::some(v.to_owned_from_source(__buffa_src)?)
                }
                None => ::buffa::MessageField::none(),
            },
            value: match self.value.as_option() {
                Some(v) => {
                    ::buffa::MessageField::<
                        super::super::CodecDeterministicCborValue,
                        ::buffa::Inline<super::super::CodecDeterministicCborValue>,
                    >::some(v.to_owned_from_source(__buffa_src)?)
                }
                None => ::buffa::MessageField::none(),
            },
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDeterministicCborMapEntryView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if self.key.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.key.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if self.value.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.value.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.key.is_set() {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.key.write_to(__cache, buf);
        }
        if self.value.is_set() {
            ::buffa::types::put_len_delimited_header(
                2u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.value.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDeterministicCborMapEntryView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        {
            if let ::core::option::Option::Some(__v) = self.key.as_option() {
                __map.serialize_entry("key", __v)?;
            }
        }
        {
            if let ::core::option::Option::Some(__v) = self.value.as_option() {
                __map.serialize_entry("value", __v)?;
            }
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDeterministicCborMapEntryView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborMapEntry";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborMapEntry";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborMapEntry";
}
::buffa::impl_default_view_instance!(CodecDeterministicCborMapEntryView);
::buffa::impl_view_reborrow!(CodecDeterministicCborMapEntryView);
#[derive(Clone, Default)]
pub struct CodecDeterministicCborArrayView<'a> {
    /// Field 1: `values`
    pub values: ::buffa::RepeatedView<
        'a,
        super::super::__buffa::view::CodecDeterministicCborValueView<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDeterministicCborArrayView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborArrayView")
            .field("values", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDeterministicCborArrayView<'a> {
    type Owned = super::super::CodecDeterministicCborArray;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                ctx.register_element_memory(
                    ::core::mem::size_of::<
                        super::super::__buffa::view::CodecDeterministicCborValueView,
                    >(),
                )?;
                view.values
                    .push(
                        <super::super::__buffa::view::CodecDeterministicCborValueView as ::buffa::MessageView>::decode_view_ctx(
                            sub,
                            __sub_ctx,
                        )?,
                    );
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborArray,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborArray,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDeterministicCborArray {
            values: self
                .values
                .iter()
                .map(|v| v.to_owned_from_source(__buffa_src))
                .collect::<::core::result::Result<_, ::buffa::DecodeError>>()?,
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDeterministicCborArrayView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        for v in &self.values {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for v in &self.values {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDeterministicCborArrayView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !self.values.is_empty() {
            __map.serialize_entry("values", &*self.values)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDeterministicCborArrayView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborArray";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborArray";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborArray";
}
::buffa::impl_default_view_instance!(CodecDeterministicCborArrayView);
::buffa::impl_view_reborrow!(CodecDeterministicCborArrayView);
#[derive(Clone, Default)]
pub struct CodecDeterministicCborMapView<'a> {
    /// Field 1: `entries`
    pub entries: ::buffa::RepeatedView<
        'a,
        super::super::__buffa::view::CodecDeterministicCborMapEntryView<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDeterministicCborMapView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborMapView")
            .field("entries", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDeterministicCborMapView<'a> {
    type Owned = super::super::CodecDeterministicCborMap;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                ctx.register_element_memory(
                    ::core::mem::size_of::<
                        super::super::__buffa::view::CodecDeterministicCborMapEntryView,
                    >(),
                )?;
                view.entries
                    .push(
                        <super::super::__buffa::view::CodecDeterministicCborMapEntryView as ::buffa::MessageView>::decode_view_ctx(
                            sub,
                            __sub_ctx,
                        )?,
                    );
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborMap,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborMap,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDeterministicCborMap {
            entries: self
                .entries
                .iter()
                .map(|v| v.to_owned_from_source(__buffa_src))
                .collect::<::core::result::Result<_, ::buffa::DecodeError>>()?,
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDeterministicCborMapView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        for v in &self.entries {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for v in &self.entries {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDeterministicCborMapView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !self.entries.is_empty() {
            __map.serialize_entry("entries", &*self.entries)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDeterministicCborMapView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborMap";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborMap";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborMap";
}
::buffa::impl_default_view_instance!(CodecDeterministicCborMapView);
::buffa::impl_view_reborrow!(CodecDeterministicCborMapView);
/// CodecDeterministicCborValue is the generated transport form of the
/// deterministic generic-CBOR semantic tree. Text, bytes, and keys are treated
/// as sensitive by generated hardening because this is a generic codec surface.
#[derive(Clone, Default)]
pub struct CodecDeterministicCborValueView<'a> {
    pub value: ::core::option::Option<
        super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDeterministicCborValueView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborValueView")
            .field("value", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDeterministicCborValueView<'a> {
    type Owned = super::super::CodecDeterministicCborValue;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::NullValue(
                        ref mut existing,
                    ),
                ) = view.value
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.value = Some(
                        super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::NullValue(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDeterministicCborNullView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::BoolValue(
                        ref mut existing,
                    ),
                ) = view.value
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.value = Some(
                        super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::BoolValue(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDeterministicCborBoolView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::IntegerValue(
                        ref mut existing,
                    ),
                ) = view.value
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.value = Some(
                        super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::IntegerValue(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDeterministicCborIntegerView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::TextValue(
                        ref mut existing,
                    ),
                ) = view.value
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.value = Some(
                        super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::TextValue(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDeterministicCborTextView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::BytesValue(
                        ref mut existing,
                    ),
                ) = view.value
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.value = Some(
                        super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::BytesValue(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDeterministicCborBytesView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::ArrayValue(
                        ref mut existing,
                    ),
                ) = view.value
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.value = Some(
                        super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::ArrayValue(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDeterministicCborArrayView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::MapValue(
                        ref mut existing,
                    ),
                ) = view.value
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.value = Some(
                        super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::MapValue(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDeterministicCborMapView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborValue,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborValue,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDeterministicCborValue {
            value: match self.value.as_ref() {
                ::core::option::Option::Some(v) => {
                    ::core::option::Option::Some(
                        match v {
                            super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::NullValue(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_deterministic_cbor_value::Value::NullValue(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::BoolValue(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_deterministic_cbor_value::Value::BoolValue(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::IntegerValue(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_deterministic_cbor_value::Value::IntegerValue(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::TextValue(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_deterministic_cbor_value::Value::TextValue(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::BytesValue(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_deterministic_cbor_value::Value::BytesValue(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::ArrayValue(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_deterministic_cbor_value::Value::ArrayValue(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::MapValue(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_deterministic_cbor_value::Value::MapValue(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                        },
                    )
                }
                ::core::option::Option::None => ::core::option::Option::None,
            },
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDeterministicCborValueView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if let ::core::option::Option::Some(ref v) = self.value {
            match v {
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::NullValue(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::BoolValue(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::IntegerValue(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::TextValue(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::BytesValue(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::ArrayValue(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::MapValue(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref v) = self.value {
            match v {
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::NullValue(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::BoolValue(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        2u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::IntegerValue(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        3u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::TextValue(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        4u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::BytesValue(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        5u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::ArrayValue(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        6u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::MapValue(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        7u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
            }
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDeterministicCborValueView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if let ::core::option::Option::Some(ref __ov) = self.value {
            match __ov {
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::NullValue(
                    v,
                ) => {
                    __map.serialize_entry("nullValue", v)?;
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::BoolValue(
                    v,
                ) => {
                    __map.serialize_entry("boolValue", v)?;
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::IntegerValue(
                    v,
                ) => {
                    __map.serialize_entry("integerValue", v)?;
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::TextValue(
                    v,
                ) => {
                    __map.serialize_entry("textValue", v)?;
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::BytesValue(
                    v,
                ) => {
                    __map.serialize_entry("bytesValue", v)?;
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::ArrayValue(
                    v,
                ) => {
                    __map.serialize_entry("arrayValue", v)?;
                }
                super::super::__buffa::view::oneof::codec_deterministic_cbor_value::Value::MapValue(
                    v,
                ) => {
                    __map.serialize_entry("mapValue", v)?;
                }
            }
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDeterministicCborValueView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborValue";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborValue";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborValue";
}
::buffa::impl_default_view_instance!(CodecDeterministicCborValueView);
::buffa::impl_view_reborrow!(CodecDeterministicCborValueView);
#[derive(Clone, Default)]
pub struct CodecDeterministicCborEncodeRequestView<'a> {
    /// Field 1: `value`
    pub value: ::buffa::MessageFieldView<
        super::super::__buffa::view::CodecDeterministicCborValueView<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDeterministicCborEncodeRequestView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborEncodeRequestView")
            .field("value", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDeterministicCborEncodeRequestView<'a> {
    type Owned = super::super::CodecDeterministicCborEncodeRequest;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                match view.value.as_mut() {
                    Some(existing) => {
                        ::buffa::MessageView::merge_into_view(existing, sub, __sub_ctx)?
                    }
                    None => {
                        view.value = ::buffa::MessageFieldView::set(
                            <super::super::__buffa::view::CodecDeterministicCborValueView as ::buffa::MessageView>::decode_view_ctx(
                                sub,
                                __sub_ctx,
                            )?,
                        );
                    }
                }
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborEncodeRequest,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborEncodeRequest,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDeterministicCborEncodeRequest {
            value: match self.value.as_option() {
                Some(v) => {
                    ::buffa::MessageField::<
                        super::super::CodecDeterministicCborValue,
                        ::buffa::Inline<super::super::CodecDeterministicCborValue>,
                    >::some(v.to_owned_from_source(__buffa_src)?)
                }
                None => ::buffa::MessageField::none(),
            },
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDeterministicCborEncodeRequestView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if self.value.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.value.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.value.is_set() {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.value.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDeterministicCborEncodeRequestView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        {
            if let ::core::option::Option::Some(__v) = self.value.as_option() {
                __map.serialize_entry("value", __v)?;
            }
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDeterministicCborEncodeRequestView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborEncodeRequest";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborEncodeRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborEncodeRequest";
}
::buffa::impl_default_view_instance!(CodecDeterministicCborEncodeRequestView);
::buffa::impl_view_reborrow!(CodecDeterministicCborEncodeRequestView);
#[derive(Clone, Default)]
pub struct CodecDeterministicCborEncodeResultView<'a> {
    /// Encoded CBOR bytes may contain the complete sensitive document.
    ///
    /// Field 1: `encoded`
    pub encoded: &'a [u8],
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDeterministicCborEncodeResultView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborEncodeResultView")
            .field("encoded", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDeterministicCborEncodeResultView<'a> {
    type Owned = super::super::CodecDeterministicCborEncodeResult;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.encoded = ::buffa::types::borrow_bytes(&mut cur)?;
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborEncodeResult,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborEncodeResult,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDeterministicCborEncodeResult {
            encoded: (self.encoded).to_vec(),
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDeterministicCborEncodeResultView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.encoded.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.encoded) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.encoded.is_empty() {
            ::buffa::types::put_shared_bytes_field(1u32, &self.encoded, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDeterministicCborEncodeResultView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_empty_bytes(self.encoded) {
            __map
                .serialize_entry(
                    "encoded",
                    &super::super::__ReallyMeSensitiveBytes(self.encoded),
                )?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDeterministicCborEncodeResultView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborEncodeResult";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborEncodeResult";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborEncodeResult";
}
::buffa::impl_default_view_instance!(CodecDeterministicCborEncodeResultView);
::buffa::impl_view_reborrow!(CodecDeterministicCborEncodeResultView);
#[derive(Clone, Default)]
pub struct CodecDeterministicCborDecodeRequestView<'a> {
    /// Encoded CBOR bytes may contain the complete sensitive document.
    ///
    /// Field 1: `encoded`
    pub encoded: &'a [u8],
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDeterministicCborDecodeRequestView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborDecodeRequestView")
            .field("encoded", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDeterministicCborDecodeRequestView<'a> {
    type Owned = super::super::CodecDeterministicCborDecodeRequest;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.encoded = ::buffa::types::borrow_bytes(&mut cur)?;
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborDecodeRequest,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborDecodeRequest,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDeterministicCborDecodeRequest {
            encoded: (self.encoded).to_vec(),
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDeterministicCborDecodeRequestView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.encoded.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.encoded) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.encoded.is_empty() {
            ::buffa::types::put_shared_bytes_field(1u32, &self.encoded, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDeterministicCborDecodeRequestView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_empty_bytes(self.encoded) {
            __map
                .serialize_entry(
                    "encoded",
                    &super::super::__ReallyMeSensitiveBytes(self.encoded),
                )?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDeterministicCborDecodeRequestView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborDecodeRequest";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborDecodeRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborDecodeRequest";
}
::buffa::impl_default_view_instance!(CodecDeterministicCborDecodeRequestView);
::buffa::impl_view_reborrow!(CodecDeterministicCborDecodeRequestView);
#[derive(Clone, Default)]
pub struct CodecDeterministicCborDecodeResultView<'a> {
    /// Field 1: `value`
    pub value: ::buffa::MessageFieldView<
        super::super::__buffa::view::CodecDeterministicCborValueView<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecDeterministicCborDecodeResultView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecDeterministicCborDecodeResultView")
            .field("value", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecDeterministicCborDecodeResultView<'a> {
    type Owned = super::super::CodecDeterministicCborDecodeResult;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                match view.value.as_mut() {
                    Some(existing) => {
                        ::buffa::MessageView::merge_into_view(existing, sub, __sub_ctx)?
                    }
                    None => {
                        view.value = ::buffa::MessageFieldView::set(
                            <super::super::__buffa::view::CodecDeterministicCborValueView as ::buffa::MessageView>::decode_view_ctx(
                                sub,
                                __sub_ctx,
                            )?,
                        );
                    }
                }
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborDecodeResult,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDeterministicCborDecodeResult,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDeterministicCborDecodeResult {
            value: match self.value.as_option() {
                Some(v) => {
                    ::buffa::MessageField::<
                        super::super::CodecDeterministicCborValue,
                        ::buffa::Inline<super::super::CodecDeterministicCborValue>,
                    >::some(v.to_owned_from_source(__buffa_src)?)
                }
                None => ::buffa::MessageField::none(),
            },
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDeterministicCborDecodeResultView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if self.value.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.value.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.value.is_set() {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.value.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDeterministicCborDecodeResultView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        {
            if let ::core::option::Option::Some(__v) = self.value.as_option() {
                __map.serialize_entry("value", __v)?;
            }
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDeterministicCborDecodeResultView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecDeterministicCborDecodeResult";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecDeterministicCborDecodeResult";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecDeterministicCborDecodeResult";
}
::buffa::impl_default_view_instance!(CodecDeterministicCborDecodeResultView);
::buffa::impl_view_reborrow!(CodecDeterministicCborDecodeResultView);
/// CodecOperationResult is the fully discriminated generated result contract for
/// structured operations.
#[derive(Clone, Default)]
pub struct CodecOperationResultView<'a> {
    pub result: ::core::option::Option<
        super::super::__buffa::view::oneof::codec_operation_result::Result<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecOperationResultView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecOperationResultView")
            .field("result", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecOperationResultView<'a> {
    type Owned = super::super::CodecOperationResult;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_result::Result::MulticodecPrefixForName(
                        ref mut existing,
                    ),
                ) = view.result
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.result = Some(
                        super::super::__buffa::view::oneof::codec_operation_result::Result::MulticodecPrefixForName(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecMulticodecSpecView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            1001u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_result::Result::MulticodecLookupPrefix(
                        ref mut existing,
                    ),
                ) = view.result
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.result = Some(
                        super::super::__buffa::view::oneof::codec_operation_result::Result::MulticodecLookupPrefix(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecMulticodecLookupResultView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            1002u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_result::Result::MulticodecTable(
                        ref mut existing,
                    ),
                ) = view.result
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.result = Some(
                        super::super::__buffa::view::oneof::codec_operation_result::Result::MulticodecTable(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecMulticodecTableResultView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            2000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_result::Result::MultikeyParse(
                        ref mut existing,
                    ),
                ) = view.result
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.result = Some(
                        super::super::__buffa::view::oneof::codec_operation_result::Result::MultikeyParse(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecMultikeyParseResultView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            3000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_result::Result::DagCborVerifyCid(
                        ref mut existing,
                    ),
                ) = view.result
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.result = Some(
                        super::super::__buffa::view::oneof::codec_operation_result::Result::DagCborVerifyCid(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDagCborVerifyCidResultView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            3001u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_result::Result::DagCborEncode(
                        ref mut existing,
                    ),
                ) = view.result
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.result = Some(
                        super::super::__buffa::view::oneof::codec_operation_result::Result::DagCborEncode(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDagCborEncodeResultView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            3002u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_result::Result::DagCborDecode(
                        ref mut existing,
                    ),
                ) = view.result
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.result = Some(
                        super::super::__buffa::view::oneof::codec_operation_result::Result::DagCborDecode(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDagCborDecodeResultView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            4000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_result::Result::PemDecode(
                        ref mut existing,
                    ),
                ) = view.result
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.result = Some(
                        super::super::__buffa::view::oneof::codec_operation_result::Result::PemDecode(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecPemDecodeResultView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            4001u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_result::Result::PemEncode(
                        ref mut existing,
                    ),
                ) = view.result
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.result = Some(
                        super::super::__buffa::view::oneof::codec_operation_result::Result::PemEncode(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecPemEncodeResultView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            5000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_result::Result::DeterministicCborEncode(
                        ref mut existing,
                    ),
                ) = view.result
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.result = Some(
                        super::super::__buffa::view::oneof::codec_operation_result::Result::DeterministicCborEncode(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDeterministicCborEncodeResultView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            5001u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_result::Result::DeterministicCborDecode(
                        ref mut existing,
                    ),
                ) = view.result
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.result = Some(
                        super::super::__buffa::view::oneof::codec_operation_result::Result::DeterministicCborDecode(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDeterministicCborDecodeResultView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecOperationResult,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecOperationResult,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecOperationResult {
            result: match self.result.as_ref() {
                ::core::option::Option::Some(v) => {
                    ::core::option::Option::Some(
                        match v {
                            super::super::__buffa::view::oneof::codec_operation_result::Result::MulticodecPrefixForName(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_result::Result::MulticodecPrefixForName(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_result::Result::MulticodecLookupPrefix(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_result::Result::MulticodecLookupPrefix(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_result::Result::MulticodecTable(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_result::Result::MulticodecTable(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_result::Result::MultikeyParse(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_result::Result::MultikeyParse(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_result::Result::DagCborVerifyCid(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_result::Result::DagCborVerifyCid(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_result::Result::DagCborEncode(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_result::Result::DagCborEncode(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_result::Result::DagCborDecode(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_result::Result::DagCborDecode(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_result::Result::PemDecode(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_result::Result::PemDecode(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_result::Result::PemEncode(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_result::Result::PemEncode(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_result::Result::DeterministicCborEncode(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_result::Result::DeterministicCborEncode(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_result::Result::DeterministicCborDecode(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_result::Result::DeterministicCborDecode(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                        },
                    )
                }
                ::core::option::Option::None => ::core::option::Option::None,
            },
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecOperationResultView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if let ::core::option::Option::Some(ref v) = self.result {
            match v {
                super::super::__buffa::view::oneof::codec_operation_result::Result::MulticodecPrefixForName(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::MulticodecLookupPrefix(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::MulticodecTable(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::MultikeyParse(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::DagCborVerifyCid(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::DagCborEncode(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::DagCborDecode(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::PemDecode(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::PemEncode(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::DeterministicCborEncode(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::DeterministicCborDecode(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref v) = self.result {
            match v {
                super::super::__buffa::view::oneof::codec_operation_result::Result::MulticodecPrefixForName(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::MulticodecLookupPrefix(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1001u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::MulticodecTable(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1002u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::MultikeyParse(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        2000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::DagCborVerifyCid(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        3000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::DagCborEncode(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        3001u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::DagCborDecode(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        3002u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::PemDecode(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        4000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::PemEncode(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        4001u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::DeterministicCborEncode(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        5000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::DeterministicCborDecode(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        5001u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
            }
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecOperationResultView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if let ::core::option::Option::Some(ref __ov) = self.result {
            match __ov {
                super::super::__buffa::view::oneof::codec_operation_result::Result::MulticodecPrefixForName(
                    v,
                ) => {
                    __map.serialize_entry("multicodecPrefixForName", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::MulticodecLookupPrefix(
                    v,
                ) => {
                    __map.serialize_entry("multicodecLookupPrefix", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::MulticodecTable(
                    v,
                ) => {
                    __map.serialize_entry("multicodecTable", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::MultikeyParse(
                    v,
                ) => {
                    __map.serialize_entry("multikeyParse", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::DagCborVerifyCid(
                    v,
                ) => {
                    __map.serialize_entry("dagCborVerifyCid", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::DagCborEncode(
                    v,
                ) => {
                    __map.serialize_entry("dagCborEncode", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::DagCborDecode(
                    v,
                ) => {
                    __map.serialize_entry("dagCborDecode", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::PemDecode(
                    v,
                ) => {
                    __map.serialize_entry("pemDecode", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::PemEncode(
                    v,
                ) => {
                    __map.serialize_entry("pemEncode", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::DeterministicCborEncode(
                    v,
                ) => {
                    __map.serialize_entry("deterministicCborEncode", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_result::Result::DeterministicCborDecode(
                    v,
                ) => {
                    __map.serialize_entry("deterministicCborDecode", v)?;
                }
            }
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecOperationResultView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecOperationResult";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecOperationResult";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecOperationResult";
}
::buffa::impl_default_view_instance!(CodecOperationResultView);
::buffa::impl_view_reborrow!(CodecOperationResultView);
/// CodecOperationResponse removes invalid status/payload combinations for new
/// structured callers by making success and failure explicit generated variants.
#[derive(Clone, Default)]
pub struct CodecOperationResponseView<'a> {
    pub outcome: ::core::option::Option<
        super::super::__buffa::view::oneof::codec_operation_response::Outcome<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecOperationResponseView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecOperationResponseView")
            .field("outcome", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecOperationResponseView<'a> {
    type Owned = super::super::CodecOperationResponse;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_response::Outcome::Result(
                        ref mut existing,
                    ),
                ) = view.outcome
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.outcome = Some(
                        super::super::__buffa::view::oneof::codec_operation_response::Outcome::Result(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecOperationResultView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_response::Outcome::Error(
                        ref mut existing,
                    ),
                ) = view.outcome
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.outcome = Some(
                        super::super::__buffa::view::oneof::codec_operation_response::Outcome::Error(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecErrorView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecOperationResponse,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecOperationResponse,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecOperationResponse {
            outcome: match self.outcome.as_ref() {
                ::core::option::Option::Some(v) => {
                    ::core::option::Option::Some(
                        match v {
                            super::super::__buffa::view::oneof::codec_operation_response::Outcome::Result(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_response::Outcome::Result(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_response::Outcome::Error(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_response::Outcome::Error(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                        },
                    )
                }
                ::core::option::Option::None => ::core::option::Option::None,
            },
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecOperationResponseView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if let ::core::option::Option::Some(ref v) = self.outcome {
            match v {
                super::super::__buffa::view::oneof::codec_operation_response::Outcome::Result(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_response::Outcome::Error(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref v) = self.outcome {
            match v {
                super::super::__buffa::view::oneof::codec_operation_response::Outcome::Result(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_response::Outcome::Error(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        2u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
            }
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecOperationResponseView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if let ::core::option::Option::Some(ref __ov) = self.outcome {
            match __ov {
                super::super::__buffa::view::oneof::codec_operation_response::Outcome::Result(
                    v,
                ) => {
                    __map.serialize_entry("result", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_response::Outcome::Error(
                    v,
                ) => {
                    __map.serialize_entry("error", v)?;
                }
            }
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecOperationResponseView<'a> {
    const PACKAGE: &'static str = "reallyme.codec.v1";
    const NAME: &'static str = "CodecOperationResponse";
    const FULL_NAME: &'static str = "reallyme.codec.v1.CodecOperationResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/reallyme.codec.v1.CodecOperationResponse";
}
::buffa::impl_default_view_instance!(CodecOperationResponseView);
::buffa::impl_view_reborrow!(CodecOperationResponseView);
/// 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, Default)]
pub struct CodecOperationRequestView<'a> {
    pub operation: ::core::option::Option<
        super::super::__buffa::view::oneof::codec_operation_request::Operation<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecOperationRequestView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecOperationRequestView")
            .field("operation", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecOperationRequestView<'a> {
    type Owned = super::super::CodecOperationRequest;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_request::Operation::MulticodecPrefixForName(
                        ref mut existing,
                    ),
                ) = view.operation
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.operation = Some(
                        super::super::__buffa::view::oneof::codec_operation_request::Operation::MulticodecPrefixForName(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecMulticodecPrefixForNameRequestView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            1001u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_request::Operation::MulticodecLookupPrefix(
                        ref mut existing,
                    ),
                ) = view.operation
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.operation = Some(
                        super::super::__buffa::view::oneof::codec_operation_request::Operation::MulticodecLookupPrefix(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecMulticodecLookupPrefixRequestView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            1002u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_request::Operation::MulticodecTable(
                        ref mut existing,
                    ),
                ) = view.operation
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.operation = Some(
                        super::super::__buffa::view::oneof::codec_operation_request::Operation::MulticodecTable(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecMulticodecTableRequestView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            2000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_request::Operation::MultikeyParse(
                        ref mut existing,
                    ),
                ) = view.operation
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.operation = Some(
                        super::super::__buffa::view::oneof::codec_operation_request::Operation::MultikeyParse(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecMultikeyParseRequestView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            3000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_request::Operation::DagCborVerifyCid(
                        ref mut existing,
                    ),
                ) = view.operation
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.operation = Some(
                        super::super::__buffa::view::oneof::codec_operation_request::Operation::DagCborVerifyCid(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDagCborVerifyCidRequestView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            3001u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_request::Operation::DagCborEncode(
                        ref mut existing,
                    ),
                ) = view.operation
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.operation = Some(
                        super::super::__buffa::view::oneof::codec_operation_request::Operation::DagCborEncode(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDagCborEncodeRequestView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            3002u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_request::Operation::DagCborDecode(
                        ref mut existing,
                    ),
                ) = view.operation
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.operation = Some(
                        super::super::__buffa::view::oneof::codec_operation_request::Operation::DagCborDecode(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDagCborDecodeRequestView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            4000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_request::Operation::PemDecode(
                        ref mut existing,
                    ),
                ) = view.operation
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.operation = Some(
                        super::super::__buffa::view::oneof::codec_operation_request::Operation::PemDecode(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecPemDecodeRequestView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            4001u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_request::Operation::PemEncode(
                        ref mut existing,
                    ),
                ) = view.operation
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.operation = Some(
                        super::super::__buffa::view::oneof::codec_operation_request::Operation::PemEncode(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecPemEncodeRequestView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            5000u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_request::Operation::DeterministicCborEncode(
                        ref mut existing,
                    ),
                ) = view.operation
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.operation = Some(
                        super::super::__buffa::view::oneof::codec_operation_request::Operation::DeterministicCborEncode(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDeterministicCborEncodeRequestView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            5001u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                if let Some(
                    super::super::__buffa::view::oneof::codec_operation_request::Operation::DeterministicCborDecode(
                        ref mut existing,
                    ),
                ) = view.operation
                {
                    ::buffa::MessageView::merge_into_view(
                        &mut **existing,
                        sub,
                        __sub_ctx,
                    )?;
                } else {
                    view.operation = Some(
                        super::super::__buffa::view::oneof::codec_operation_request::Operation::DeterministicCborDecode(
                            ::buffa::alloc::boxed::Box::new(
                                <super::super::__buffa::view::CodecDeterministicCborDecodeRequestView as ::buffa::MessageView>::decode_view_ctx(
                                    sub,
                                    __sub_ctx,
                                )?,
                            ),
                        ),
                    );
                }
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecOperationRequest,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecOperationRequest,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecOperationRequest {
            operation: match self.operation.as_ref() {
                ::core::option::Option::Some(v) => {
                    ::core::option::Option::Some(
                        match v {
                            super::super::__buffa::view::oneof::codec_operation_request::Operation::MulticodecPrefixForName(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_request::Operation::MulticodecPrefixForName(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_request::Operation::MulticodecLookupPrefix(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_request::Operation::MulticodecLookupPrefix(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_request::Operation::MulticodecTable(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_request::Operation::MulticodecTable(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_request::Operation::MultikeyParse(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_request::Operation::MultikeyParse(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_request::Operation::DagCborVerifyCid(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_request::Operation::DagCborVerifyCid(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_request::Operation::DagCborEncode(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_request::Operation::DagCborEncode(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_request::Operation::DagCborDecode(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_request::Operation::DagCborDecode(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_request::Operation::PemDecode(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_request::Operation::PemDecode(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_request::Operation::PemEncode(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_request::Operation::PemEncode(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_request::Operation::DeterministicCborEncode(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_request::Operation::DeterministicCborEncode(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                            super::super::__buffa::view::oneof::codec_operation_request::Operation::DeterministicCborDecode(
                                v,
                            ) => {
                                super::super::__buffa::oneof::codec_operation_request::Operation::DeterministicCborDecode(
                                    ::buffa::alloc::boxed::Box::new(
                                        v.to_owned_from_source(__buffa_src)?,
                                    ),
                                )
                            }
                        },
                    )
                }
                ::core::option::Option::None => ::core::option::Option::None,
            },
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecOperationRequestView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if let ::core::option::Option::Some(ref v) = self.operation {
            match v {
                super::super::__buffa::view::oneof::codec_operation_request::Operation::MulticodecPrefixForName(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::MulticodecLookupPrefix(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::MulticodecTable(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::MultikeyParse(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 2u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::DagCborVerifyCid(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::DagCborEncode(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::DagCborDecode(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::PemDecode(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::PemEncode(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::DeterministicCborEncode(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::DeterministicCborDecode(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 3u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if let ::core::option::Option::Some(ref v) = self.operation {
            match v {
                super::super::__buffa::view::oneof::codec_operation_request::Operation::MulticodecPrefixForName(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::MulticodecLookupPrefix(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1001u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::MulticodecTable(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        1002u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::MultikeyParse(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        2000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::DagCborVerifyCid(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        3000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::DagCborEncode(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        3001u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::DagCborDecode(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        3002u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::PemDecode(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        4000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::PemEncode(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        4001u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::DeterministicCborEncode(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        5000u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::DeterministicCborDecode(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        5001u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
            }
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecOperationRequestView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if let ::core::option::Option::Some(ref __ov) = self.operation {
            match __ov {
                super::super::__buffa::view::oneof::codec_operation_request::Operation::MulticodecPrefixForName(
                    v,
                ) => {
                    __map.serialize_entry("multicodecPrefixForName", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::MulticodecLookupPrefix(
                    v,
                ) => {
                    __map.serialize_entry("multicodecLookupPrefix", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::MulticodecTable(
                    v,
                ) => {
                    __map.serialize_entry("multicodecTable", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::MultikeyParse(
                    v,
                ) => {
                    __map.serialize_entry("multikeyParse", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::DagCborVerifyCid(
                    v,
                ) => {
                    __map.serialize_entry("dagCborVerifyCid", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::DagCborEncode(
                    v,
                ) => {
                    __map.serialize_entry("dagCborEncode", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::DagCborDecode(
                    v,
                ) => {
                    __map.serialize_entry("dagCborDecode", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::PemDecode(
                    v,
                ) => {
                    __map.serialize_entry("pemDecode", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::PemEncode(
                    v,
                ) => {
                    __map.serialize_entry("pemEncode", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::DeterministicCborEncode(
                    v,
                ) => {
                    __map.serialize_entry("deterministicCborEncode", v)?;
                }
                super::super::__buffa::view::oneof::codec_operation_request::Operation::DeterministicCborDecode(
                    v,
                ) => {
                    __map.serialize_entry("deterministicCborDecode", v)?;
                }
            }
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecOperationRequestView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecOperationRequestView);
::buffa::impl_view_reborrow!(CodecOperationRequestView);
/// CodecMulticodecSpec is the protobuf form of a multicodec table entry.
#[derive(Clone, Debug, Default)]
pub struct CodecMulticodecSpecView<'a> {
    /// Field 1: `name`
    pub name: &'a str,
    /// Raw multicodec varint bytes for callers that need the numeric code
    /// encoding independent of any payload.
    ///
    /// Field 2: `code`
    pub code: &'a [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`
    pub prefix: &'a [u8],
    /// Field 4: `tag`
    pub tag: ::buffa::EnumValue<super::super::CodecTag>,
    /// Field 5: `key_material_kind`
    pub key_material_kind: ::buffa::EnumValue<super::super::CodecKeyMaterialKind>,
    /// Field 6: `fixed_length`
    pub fixed_length: u32,
    /// Field 7: `variable_length`
    pub variable_length: bool,
    /// Field 8: `algorithm_name`
    pub algorithm_name: &'a str,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::buffa::MessageView<'a> for CodecMulticodecSpecView<'a> {
    type Owned = super::super::CodecMulticodecSpec;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.name = ::buffa::types::borrow_str(&mut cur)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.code = ::buffa::types::borrow_bytes(&mut cur)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.prefix = ::buffa::types::borrow_bytes(&mut cur)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.tag = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(&mut cur)?,
                );
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.key_material_kind = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(&mut cur)?,
                );
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.fixed_length = ::buffa::types::decode_uint32(&mut cur)?;
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.variable_length = ::buffa::types::decode_bool(&mut cur)?;
            }
            8u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.algorithm_name = ::buffa::types::borrow_str(&mut cur)?;
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecMulticodecSpec,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecMulticodecSpec,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecMulticodecSpec {
            name: self.name.to_string(),
            code: (self.code).to_vec(),
            prefix: (self.prefix).to_vec(),
            tag: self.tag,
            key_material_kind: self.key_material_kind,
            fixed_length: self.fixed_length,
            variable_length: self.variable_length,
            algorithm_name: self.algorithm_name.to_string(),
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecMulticodecSpecView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.name.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.name) as u64;
        }
        if !self.code.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.code) as u64;
        }
        if !self.prefix.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.prefix) as u64;
        }
        {
            let val = self.tag.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) as u64;
            }
        }
        {
            let val = self.key_material_kind.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) as u64;
            }
        }
        if self.fixed_length != 0u32 {
            size += 1u64 + ::buffa::types::uint32_encoded_len(self.fixed_length) as u64;
        }
        if self.variable_length {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if !self.algorithm_name.is_empty() {
            size
                += 1u64
                    + ::buffa::types::string_encoded_len(&self.algorithm_name) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.name.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.name, buf);
        }
        if !self.code.is_empty() {
            ::buffa::types::put_shared_bytes_field(2u32, &self.code, buf);
        }
        if !self.prefix.is_empty() {
            ::buffa::types::put_shared_bytes_field(3u32, &self.prefix, buf);
        }
        {
            let val = self.tag.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(4u32, val, buf);
            }
        }
        {
            let val = self.key_material_kind.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(5u32, val, buf);
            }
        }
        if self.fixed_length != 0u32 {
            ::buffa::types::put_uint32_field(6u32, self.fixed_length, buf);
        }
        if self.variable_length {
            ::buffa::types::put_bool_field(7u32, self.variable_length, buf);
        }
        if !self.algorithm_name.is_empty() {
            ::buffa::types::put_string_field(8u32, &self.algorithm_name, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecMulticodecSpecView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_empty_str(self.name) {
            __map.serialize_entry("name", self.name)?;
        }
        if !::buffa::json_helpers::skip_if::is_empty_bytes(self.code) {
            __map.serialize_entry("code", &::buffa::json_helpers::BytesJson(self.code))?;
        }
        if !::buffa::json_helpers::skip_if::is_empty_bytes(self.prefix) {
            __map
                .serialize_entry(
                    "prefix",
                    &::buffa::json_helpers::BytesJson(self.prefix),
                )?;
        }
        if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.tag) {
            __map.serialize_entry("tag", &self.tag)?;
        }
        if !::buffa::json_helpers::skip_if::is_default_enum_value(
            &self.key_material_kind,
        ) {
            __map.serialize_entry("keyMaterialKind", &self.key_material_kind)?;
        }
        if !::buffa::json_helpers::skip_if::is_zero_u32(&self.fixed_length) {
            __map
                .serialize_entry(
                    "fixedLength",
                    &::buffa::json_helpers::ProtoJson(&self.fixed_length),
                )?;
        }
        if self.variable_length {
            __map.serialize_entry("variableLength", &self.variable_length)?;
        }
        if !::buffa::json_helpers::skip_if::is_empty_str(self.algorithm_name) {
            __map.serialize_entry("algorithmName", self.algorithm_name)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecMulticodecSpecView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecMulticodecSpecView);
::buffa::impl_view_reborrow!(CodecMulticodecSpecView);
/** Self-contained, `'static` owned view of a `CodecMulticodecSpec` message.

 Wraps [`::buffa::OwnedView`]`<`[`CodecMulticodecSpecView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CodecMulticodecSpecView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct CodecMulticodecSpecOwnedView(
    ::buffa::OwnedView<CodecMulticodecSpecView<'static>>,
);
impl CodecMulticodecSpecOwnedView {
    /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
    ///
    /// The view borrows directly from the buffer's data; the buffer is
    /// retained inside the returned handle.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
    /// protobuf data.
    pub fn decode(
        bytes: ::buffa::bytes::Bytes,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecMulticodecSpecOwnedView(::buffa::OwnedView::decode(bytes)?),
        )
    }
    /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
    /// max message size).
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
    /// exceeds the configured limits.
    pub fn decode_with_options(
        bytes: ::buffa::bytes::Bytes,
        opts: &::buffa::DecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecMulticodecSpecOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError::MessageTooLarge`] if the
    /// message's encoded size exceeds the 2 GiB protobuf limit, or
    /// another [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::CodecMulticodecSpec,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecMulticodecSpecOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`CodecMulticodecSpecView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &CodecMulticodecSpecView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    ///
    /// Infallible: this type's constructors wire-decode their
    /// buffer, and a view produced by wire decoding always
    /// converts. Delegates to [`::buffa::OwnedView::to_owned_message`],
    /// whose contract also governs handles converted from a raw
    /// [`::buffa::OwnedView`].
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::CodecMulticodecSpec {
        self.0.to_owned_message()
    }
    /// The underlying bytes buffer.
    #[must_use]
    pub fn bytes(&self) -> &::buffa::bytes::Bytes {
        self.0.bytes()
    }
    /// Consume the handle, returning the underlying bytes buffer.
    #[must_use]
    pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
        self.0.into_bytes()
    }
    /// Field 1: `name`
    #[must_use]
    pub fn name(&self) -> &'_ str {
        self.0.reborrow().name
    }
    /// Raw multicodec varint bytes for callers that need the numeric code
    /// encoding independent of any payload.
    ///
    /// Field 2: `code`
    #[must_use]
    pub fn code(&self) -> &'_ [u8] {
        self.0.reborrow().code
    }
    /// 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`
    #[must_use]
    pub fn prefix(&self) -> &'_ [u8] {
        self.0.reborrow().prefix
    }
    /// Field 4: `tag`
    #[must_use]
    pub fn tag(&self) -> ::buffa::EnumValue<super::super::CodecTag> {
        self.0.reborrow().tag
    }
    /// Field 5: `key_material_kind`
    #[must_use]
    pub fn key_material_kind(
        &self,
    ) -> ::buffa::EnumValue<super::super::CodecKeyMaterialKind> {
        self.0.reborrow().key_material_kind
    }
    /// Field 6: `fixed_length`
    #[must_use]
    pub fn fixed_length(&self) -> u32 {
        self.0.reborrow().fixed_length
    }
    /// Field 7: `variable_length`
    #[must_use]
    pub fn variable_length(&self) -> bool {
        self.0.reborrow().variable_length
    }
    /// Field 8: `algorithm_name`
    #[must_use]
    pub fn algorithm_name(&self) -> &'_ str {
        self.0.reborrow().algorithm_name
    }
}
impl ::core::convert::From<::buffa::OwnedView<CodecMulticodecSpecView<'static>>>
for CodecMulticodecSpecOwnedView {
    fn from(inner: ::buffa::OwnedView<CodecMulticodecSpecView<'static>>) -> Self {
        CodecMulticodecSpecOwnedView(inner)
    }
}
impl ::core::convert::From<CodecMulticodecSpecOwnedView>
for ::buffa::OwnedView<CodecMulticodecSpecView<'static>> {
    fn from(wrapper: CodecMulticodecSpecOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<CodecMulticodecSpecView<'static>>>
for CodecMulticodecSpecOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<CodecMulticodecSpecView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::CodecMulticodecSpec {
    type View<'a> = CodecMulticodecSpecView<'a>;
    type ViewHandle = CodecMulticodecSpecOwnedView;
}
impl ::serde::Serialize for CodecMulticodecSpecOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
/// CodecMulticodecLookupResult is returned when bytes are matched against the
/// supported multicodec prefix table.
#[derive(Clone, Debug, Default)]
pub struct CodecMulticodecLookupResultView<'a> {
    /// Field 1: `name`
    pub name: &'a str,
    /// Field 2: `prefix_length`
    pub prefix_length: u32,
    /// Field 3: `metadata`
    pub metadata: ::buffa::MessageFieldView<
        super::super::__buffa::view::CodecMulticodecSpecView<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::buffa::MessageView<'a> for CodecMulticodecLookupResultView<'a> {
    type Owned = super::super::CodecMulticodecLookupResult;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.name = ::buffa::types::borrow_str(&mut cur)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.prefix_length = ::buffa::types::decode_uint32(&mut cur)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                match view.metadata.as_mut() {
                    Some(existing) => {
                        ::buffa::MessageView::merge_into_view(existing, sub, __sub_ctx)?
                    }
                    None => {
                        view.metadata = ::buffa::MessageFieldView::set(
                            <super::super::__buffa::view::CodecMulticodecSpecView as ::buffa::MessageView>::decode_view_ctx(
                                sub,
                                __sub_ctx,
                            )?,
                        );
                    }
                }
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecMulticodecLookupResult,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecMulticodecLookupResult,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecMulticodecLookupResult {
            name: self.name.to_string(),
            prefix_length: self.prefix_length,
            metadata: match self.metadata.as_option() {
                Some(v) => {
                    ::buffa::MessageField::<
                        super::super::CodecMulticodecSpec,
                        ::buffa::Inline<super::super::CodecMulticodecSpec>,
                    >::some(v.to_owned_from_source(__buffa_src)?)
                }
                None => ::buffa::MessageField::none(),
            },
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecMulticodecLookupResultView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.name.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.name) as u64;
        }
        if self.prefix_length != 0u32 {
            size += 1u64 + ::buffa::types::uint32_encoded_len(self.prefix_length) as u64;
        }
        if self.metadata.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.metadata.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.name.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.name, buf);
        }
        if self.prefix_length != 0u32 {
            ::buffa::types::put_uint32_field(2u32, self.prefix_length, buf);
        }
        if self.metadata.is_set() {
            ::buffa::types::put_len_delimited_header(
                3u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.metadata.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecMulticodecLookupResultView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_empty_str(self.name) {
            __map.serialize_entry("name", self.name)?;
        }
        if !::buffa::json_helpers::skip_if::is_zero_u32(&self.prefix_length) {
            __map
                .serialize_entry(
                    "prefixLength",
                    &::buffa::json_helpers::ProtoJson(&self.prefix_length),
                )?;
        }
        {
            if let ::core::option::Option::Some(__v) = self.metadata.as_option() {
                __map.serialize_entry("metadata", __v)?;
            }
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecMulticodecLookupResultView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecMulticodecLookupResultView);
::buffa::impl_view_reborrow!(CodecMulticodecLookupResultView);
/** Self-contained, `'static` owned view of a `CodecMulticodecLookupResult` message.

 Wraps [`::buffa::OwnedView`]`<`[`CodecMulticodecLookupResultView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CodecMulticodecLookupResultView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct CodecMulticodecLookupResultOwnedView(
    ::buffa::OwnedView<CodecMulticodecLookupResultView<'static>>,
);
impl CodecMulticodecLookupResultOwnedView {
    /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
    ///
    /// The view borrows directly from the buffer's data; the buffer is
    /// retained inside the returned handle.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
    /// protobuf data.
    pub fn decode(
        bytes: ::buffa::bytes::Bytes,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecMulticodecLookupResultOwnedView(::buffa::OwnedView::decode(bytes)?),
        )
    }
    /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
    /// max message size).
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
    /// exceeds the configured limits.
    pub fn decode_with_options(
        bytes: ::buffa::bytes::Bytes,
        opts: &::buffa::DecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecMulticodecLookupResultOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError::MessageTooLarge`] if the
    /// message's encoded size exceeds the 2 GiB protobuf limit, or
    /// another [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::CodecMulticodecLookupResult,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecMulticodecLookupResultOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`CodecMulticodecLookupResultView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &CodecMulticodecLookupResultView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    ///
    /// Infallible: this type's constructors wire-decode their
    /// buffer, and a view produced by wire decoding always
    /// converts. Delegates to [`::buffa::OwnedView::to_owned_message`],
    /// whose contract also governs handles converted from a raw
    /// [`::buffa::OwnedView`].
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::CodecMulticodecLookupResult {
        self.0.to_owned_message()
    }
    /// The underlying bytes buffer.
    #[must_use]
    pub fn bytes(&self) -> &::buffa::bytes::Bytes {
        self.0.bytes()
    }
    /// Consume the handle, returning the underlying bytes buffer.
    #[must_use]
    pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
        self.0.into_bytes()
    }
    /// Field 1: `name`
    #[must_use]
    pub fn name(&self) -> &'_ str {
        self.0.reborrow().name
    }
    /// Field 2: `prefix_length`
    #[must_use]
    pub fn prefix_length(&self) -> u32 {
        self.0.reborrow().prefix_length
    }
    /// Field 3: `metadata`
    #[must_use]
    pub fn metadata(
        &self,
    ) -> &::buffa::MessageFieldView<
        super::super::__buffa::view::CodecMulticodecSpecView<'_>,
    > {
        &self.0.reborrow().metadata
    }
}
impl ::core::convert::From<::buffa::OwnedView<CodecMulticodecLookupResultView<'static>>>
for CodecMulticodecLookupResultOwnedView {
    fn from(
        inner: ::buffa::OwnedView<CodecMulticodecLookupResultView<'static>>,
    ) -> Self {
        CodecMulticodecLookupResultOwnedView(inner)
    }
}
impl ::core::convert::From<CodecMulticodecLookupResultOwnedView>
for ::buffa::OwnedView<CodecMulticodecLookupResultView<'static>> {
    fn from(wrapper: CodecMulticodecLookupResultOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<CodecMulticodecLookupResultView<'static>>>
for CodecMulticodecLookupResultOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<CodecMulticodecLookupResultView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::CodecMulticodecLookupResult {
    type View<'a> = CodecMulticodecLookupResultView<'a>;
    type ViewHandle = CodecMulticodecLookupResultOwnedView;
}
impl ::serde::Serialize for CodecMulticodecLookupResultOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
/// CodecMulticodecTableResult contains the supported multicodec entries.
#[derive(Clone, Debug, Default)]
pub struct CodecMulticodecTableResultView<'a> {
    /// Field 1: `entries`
    pub entries: ::buffa::RepeatedView<
        'a,
        super::super::__buffa::view::CodecMulticodecSpecView<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::buffa::MessageView<'a> for CodecMulticodecTableResultView<'a> {
    type Owned = super::super::CodecMulticodecTableResult;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __sub_ctx = ctx.descend()?;
                let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                ctx.register_element_memory(
                    ::core::mem::size_of::<
                        super::super::__buffa::view::CodecMulticodecSpecView,
                    >(),
                )?;
                view.entries
                    .push(
                        <super::super::__buffa::view::CodecMulticodecSpecView as ::buffa::MessageView>::decode_view_ctx(
                            sub,
                            __sub_ctx,
                        )?,
                    );
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecMulticodecTableResult,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecMulticodecTableResult,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecMulticodecTableResult {
            entries: self
                .entries
                .iter()
                .map(|v| v.to_owned_from_source(__buffa_src))
                .collect::<::core::result::Result<_, ::buffa::DecodeError>>()?,
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecMulticodecTableResultView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        for v in &self.entries {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for v in &self.entries {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecMulticodecTableResultView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !self.entries.is_empty() {
            __map.serialize_entry("entries", &*self.entries)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecMulticodecTableResultView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecMulticodecTableResultView);
::buffa::impl_view_reborrow!(CodecMulticodecTableResultView);
/** Self-contained, `'static` owned view of a `CodecMulticodecTableResult` message.

 Wraps [`::buffa::OwnedView`]`<`[`CodecMulticodecTableResultView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CodecMulticodecTableResultView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct CodecMulticodecTableResultOwnedView(
    ::buffa::OwnedView<CodecMulticodecTableResultView<'static>>,
);
impl CodecMulticodecTableResultOwnedView {
    /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
    ///
    /// The view borrows directly from the buffer's data; the buffer is
    /// retained inside the returned handle.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
    /// protobuf data.
    pub fn decode(
        bytes: ::buffa::bytes::Bytes,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecMulticodecTableResultOwnedView(::buffa::OwnedView::decode(bytes)?),
        )
    }
    /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
    /// max message size).
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
    /// exceeds the configured limits.
    pub fn decode_with_options(
        bytes: ::buffa::bytes::Bytes,
        opts: &::buffa::DecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecMulticodecTableResultOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError::MessageTooLarge`] if the
    /// message's encoded size exceeds the 2 GiB protobuf limit, or
    /// another [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::CodecMulticodecTableResult,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecMulticodecTableResultOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`CodecMulticodecTableResultView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &CodecMulticodecTableResultView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    ///
    /// Infallible: this type's constructors wire-decode their
    /// buffer, and a view produced by wire decoding always
    /// converts. Delegates to [`::buffa::OwnedView::to_owned_message`],
    /// whose contract also governs handles converted from a raw
    /// [`::buffa::OwnedView`].
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::CodecMulticodecTableResult {
        self.0.to_owned_message()
    }
    /// The underlying bytes buffer.
    #[must_use]
    pub fn bytes(&self) -> &::buffa::bytes::Bytes {
        self.0.bytes()
    }
    /// Consume the handle, returning the underlying bytes buffer.
    #[must_use]
    pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
        self.0.into_bytes()
    }
    /// Field 1: `entries`
    #[must_use]
    pub fn entries(
        &self,
    ) -> &::buffa::RepeatedView<
        '_,
        super::super::__buffa::view::CodecMulticodecSpecView<'_>,
    > {
        &self.0.reborrow().entries
    }
}
impl ::core::convert::From<::buffa::OwnedView<CodecMulticodecTableResultView<'static>>>
for CodecMulticodecTableResultOwnedView {
    fn from(inner: ::buffa::OwnedView<CodecMulticodecTableResultView<'static>>) -> Self {
        CodecMulticodecTableResultOwnedView(inner)
    }
}
impl ::core::convert::From<CodecMulticodecTableResultOwnedView>
for ::buffa::OwnedView<CodecMulticodecTableResultView<'static>> {
    fn from(wrapper: CodecMulticodecTableResultOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<CodecMulticodecTableResultView<'static>>>
for CodecMulticodecTableResultOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<CodecMulticodecTableResultView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::CodecMulticodecTableResult {
    type View<'a> = CodecMulticodecTableResultView<'a>;
    type ViewHandle = CodecMulticodecTableResultOwnedView;
}
impl ::serde::Serialize for CodecMulticodecTableResultOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
/// CodecMultikeyParseResult is the binary/protobuf form of multikey parsing.
#[derive(Clone, Default)]
pub struct CodecMultikeyParseResultView<'a> {
    /// Field 1: `codec_name`
    pub codec_name: &'a str,
    /// Field 2: `algorithm_name`
    pub algorithm_name: &'a str,
    /// Field 3: `public_key`
    pub public_key: &'a [u8],
    /// Field 4: `expected_public_key_length`
    pub expected_public_key_length: u32,
    /// Field 5: `variable_public_key_length`
    pub variable_public_key_length: bool,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecMultikeyParseResultView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecMultikeyParseResultView")
            .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()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecMultikeyParseResultView<'a> {
    type Owned = super::super::CodecMultikeyParseResult;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.codec_name = ::buffa::types::borrow_str(&mut cur)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.algorithm_name = ::buffa::types::borrow_str(&mut cur)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.public_key = ::buffa::types::borrow_bytes(&mut cur)?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.expected_public_key_length = ::buffa::types::decode_uint32(
                    &mut cur,
                )?;
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.variable_public_key_length = ::buffa::types::decode_bool(&mut cur)?;
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecMultikeyParseResult,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecMultikeyParseResult,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecMultikeyParseResult {
            codec_name: self.codec_name.to_string(),
            algorithm_name: self.algorithm_name.to_string(),
            public_key: (self.public_key).to_vec(),
            expected_public_key_length: self.expected_public_key_length,
            variable_public_key_length: self.variable_public_key_length,
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecMultikeyParseResultView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.codec_name.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.codec_name) as u64;
        }
        if !self.algorithm_name.is_empty() {
            size
                += 1u64
                    + ::buffa::types::string_encoded_len(&self.algorithm_name) as u64;
        }
        if !self.public_key.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.public_key) as u64;
        }
        if self.expected_public_key_length != 0u32 {
            size
                += 1u64
                    + ::buffa::types::uint32_encoded_len(self.expected_public_key_length)
                        as u64;
        }
        if self.variable_public_key_length {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.codec_name.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.codec_name, buf);
        }
        if !self.algorithm_name.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.algorithm_name, buf);
        }
        if !self.public_key.is_empty() {
            ::buffa::types::put_shared_bytes_field(3u32, &self.public_key, buf);
        }
        if self.expected_public_key_length != 0u32 {
            ::buffa::types::put_uint32_field(4u32, self.expected_public_key_length, buf);
        }
        if self.variable_public_key_length {
            ::buffa::types::put_bool_field(5u32, self.variable_public_key_length, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecMultikeyParseResultView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_empty_str(self.codec_name) {
            __map.serialize_entry("codecName", self.codec_name)?;
        }
        if !::buffa::json_helpers::skip_if::is_empty_str(self.algorithm_name) {
            __map.serialize_entry("algorithmName", self.algorithm_name)?;
        }
        if !::buffa::json_helpers::skip_if::is_empty_bytes(self.public_key) {
            __map
                .serialize_entry(
                    "publicKey",
                    &super::super::__ReallyMeSensitiveBytes(self.public_key),
                )?;
        }
        if !::buffa::json_helpers::skip_if::is_zero_u32(
            &self.expected_public_key_length,
        ) {
            __map
                .serialize_entry(
                    "expectedPublicKeyLength",
                    &::buffa::json_helpers::ProtoJson(&self.expected_public_key_length),
                )?;
        }
        if self.variable_public_key_length {
            __map
                .serialize_entry(
                    "variablePublicKeyLength",
                    &self.variable_public_key_length,
                )?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecMultikeyParseResultView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecMultikeyParseResultView);
::buffa::impl_view_reborrow!(CodecMultikeyParseResultView);
/// CodecDagCborVerifyCidResult contains the deterministic CID verification
/// result without requiring callers to parse fixed-shape JSON.
#[derive(Clone, Debug, Default)]
pub struct CodecDagCborVerifyCidResultView<'a> {
    /// Field 1: `valid`
    pub valid: bool,
    /// Field 2: `expected_cid`
    pub expected_cid: &'a str,
    /// Field 3: `actual_cid`
    pub actual_cid: &'a str,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::buffa::MessageView<'a> for CodecDagCborVerifyCidResultView<'a> {
    type Owned = super::super::CodecDagCborVerifyCidResult;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.valid = ::buffa::types::decode_bool(&mut cur)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.expected_cid = ::buffa::types::borrow_str(&mut cur)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.actual_cid = ::buffa::types::borrow_str(&mut cur)?;
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecDagCborVerifyCidResult,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecDagCborVerifyCidResult,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecDagCborVerifyCidResult {
            valid: self.valid,
            expected_cid: self.expected_cid.to_string(),
            actual_cid: self.actual_cid.to_string(),
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecDagCborVerifyCidResultView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if self.valid {
            size += 1u64 + ::buffa::types::BOOL_ENCODED_LEN as u64;
        }
        if !self.expected_cid.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.expected_cid) as u64;
        }
        if !self.actual_cid.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.actual_cid) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.valid {
            ::buffa::types::put_bool_field(1u32, self.valid, buf);
        }
        if !self.expected_cid.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.expected_cid, buf);
        }
        if !self.actual_cid.is_empty() {
            ::buffa::types::put_string_field(3u32, &self.actual_cid, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecDagCborVerifyCidResultView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if self.valid {
            __map.serialize_entry("valid", &self.valid)?;
        }
        if !::buffa::json_helpers::skip_if::is_empty_str(self.expected_cid) {
            __map.serialize_entry("expectedCid", self.expected_cid)?;
        }
        if !::buffa::json_helpers::skip_if::is_empty_str(self.actual_cid) {
            __map.serialize_entry("actualCid", self.actual_cid)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecDagCborVerifyCidResultView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecDagCborVerifyCidResultView);
::buffa::impl_view_reborrow!(CodecDagCborVerifyCidResultView);
/** Self-contained, `'static` owned view of a `CodecDagCborVerifyCidResult` message.

 Wraps [`::buffa::OwnedView`]`<`[`CodecDagCborVerifyCidResultView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CodecDagCborVerifyCidResultView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct CodecDagCborVerifyCidResultOwnedView(
    ::buffa::OwnedView<CodecDagCborVerifyCidResultView<'static>>,
);
impl CodecDagCborVerifyCidResultOwnedView {
    /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
    ///
    /// The view borrows directly from the buffer's data; the buffer is
    /// retained inside the returned handle.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
    /// protobuf data.
    pub fn decode(
        bytes: ::buffa::bytes::Bytes,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecDagCborVerifyCidResultOwnedView(::buffa::OwnedView::decode(bytes)?),
        )
    }
    /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
    /// max message size).
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
    /// exceeds the configured limits.
    pub fn decode_with_options(
        bytes: ::buffa::bytes::Bytes,
        opts: &::buffa::DecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecDagCborVerifyCidResultOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError::MessageTooLarge`] if the
    /// message's encoded size exceeds the 2 GiB protobuf limit, or
    /// another [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::CodecDagCborVerifyCidResult,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecDagCborVerifyCidResultOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`CodecDagCborVerifyCidResultView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &CodecDagCborVerifyCidResultView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    ///
    /// Infallible: this type's constructors wire-decode their
    /// buffer, and a view produced by wire decoding always
    /// converts. Delegates to [`::buffa::OwnedView::to_owned_message`],
    /// whose contract also governs handles converted from a raw
    /// [`::buffa::OwnedView`].
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::CodecDagCborVerifyCidResult {
        self.0.to_owned_message()
    }
    /// The underlying bytes buffer.
    #[must_use]
    pub fn bytes(&self) -> &::buffa::bytes::Bytes {
        self.0.bytes()
    }
    /// Consume the handle, returning the underlying bytes buffer.
    #[must_use]
    pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
        self.0.into_bytes()
    }
    /// Field 1: `valid`
    #[must_use]
    pub fn valid(&self) -> bool {
        self.0.reborrow().valid
    }
    /// Field 2: `expected_cid`
    #[must_use]
    pub fn expected_cid(&self) -> &'_ str {
        self.0.reborrow().expected_cid
    }
    /// Field 3: `actual_cid`
    #[must_use]
    pub fn actual_cid(&self) -> &'_ str {
        self.0.reborrow().actual_cid
    }
}
impl ::core::convert::From<::buffa::OwnedView<CodecDagCborVerifyCidResultView<'static>>>
for CodecDagCborVerifyCidResultOwnedView {
    fn from(
        inner: ::buffa::OwnedView<CodecDagCborVerifyCidResultView<'static>>,
    ) -> Self {
        CodecDagCborVerifyCidResultOwnedView(inner)
    }
}
impl ::core::convert::From<CodecDagCborVerifyCidResultOwnedView>
for ::buffa::OwnedView<CodecDagCborVerifyCidResultView<'static>> {
    fn from(wrapper: CodecDagCborVerifyCidResultOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<CodecDagCborVerifyCidResultView<'static>>>
for CodecDagCborVerifyCidResultOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<CodecDagCborVerifyCidResultView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::CodecDagCborVerifyCidResult {
    type View<'a> = CodecDagCborVerifyCidResultView<'a>;
    type ViewHandle = CodecDagCborVerifyCidResultOwnedView;
}
impl ::serde::Serialize for CodecDagCborVerifyCidResultOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
/// CodecPemDecodeResult is the binary/protobuf form of PEM armor decoding.
#[derive(Clone, Default)]
pub struct CodecPemDecodeResultView<'a> {
    /// Field 1: `label`
    pub label: &'a str,
    /// 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`
    pub der: &'a [u8],
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::core::fmt::Debug for CodecPemDecodeResultView<'a> {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("CodecPemDecodeResultView")
            .field("label", &self.label)
            .field("der", &"<redacted>")
            .finish()
    }
}

impl<'a> ::buffa::MessageView<'a> for CodecPemDecodeResultView<'a> {
    type Owned = super::super::CodecPemDecodeResult;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.label = ::buffa::types::borrow_str(&mut cur)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                view.der = ::buffa::types::borrow_bytes(&mut cur)?;
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecPemDecodeResult,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecPemDecodeResult,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecPemDecodeResult {
            label: self.label.to_string(),
            der: (self.der).to_vec(),
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecPemDecodeResultView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.label.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.label) as u64;
        }
        if !self.der.is_empty() {
            size += 1u64 + ::buffa::types::bytes_encoded_len(&self.der) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.label.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.label, buf);
        }
        if !self.der.is_empty() {
            ::buffa::types::put_shared_bytes_field(2u32, &self.der, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecPemDecodeResultView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_empty_str(self.label) {
            __map.serialize_entry("label", self.label)?;
        }
        if !::buffa::json_helpers::skip_if::is_empty_bytes(self.der) {
            __map.serialize_entry("der", &super::super::__ReallyMeSensitiveBytes(self.der))?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecPemDecodeResultView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecPemDecodeResultView);
::buffa::impl_view_reborrow!(CodecPemDecodeResultView);
/// CodecBaseEncodingError describes base64, base64url, hex, and generic byte
/// encoding failures.
#[derive(Clone, Debug, Default)]
pub struct CodecBaseEncodingErrorView<'a> {
    /// Reason must be one of the CODEC_ERROR_REASON_BASE_* values.
    ///
    /// Field 1: `reason`
    pub reason: ::buffa::EnumValue<super::super::CodecErrorReason>,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::buffa::MessageView<'a> for CodecBaseEncodingErrorView<'a> {
    type Owned = super::super::CodecBaseEncodingError;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.reason = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(&mut cur)?,
                );
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecBaseEncodingError,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecBaseEncodingError,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecBaseEncodingError {
            reason: self.reason,
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecBaseEncodingErrorView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) as u64;
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, buf);
            }
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecBaseEncodingErrorView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.reason) {
            __map.serialize_entry("reason", &self.reason)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecBaseEncodingErrorView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecBaseEncodingErrorView);
::buffa::impl_view_reborrow!(CodecBaseEncodingErrorView);
/** Self-contained, `'static` owned view of a `CodecBaseEncodingError` message.

 Wraps [`::buffa::OwnedView`]`<`[`CodecBaseEncodingErrorView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CodecBaseEncodingErrorView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct CodecBaseEncodingErrorOwnedView(
    ::buffa::OwnedView<CodecBaseEncodingErrorView<'static>>,
);
impl CodecBaseEncodingErrorOwnedView {
    /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
    ///
    /// The view borrows directly from the buffer's data; the buffer is
    /// retained inside the returned handle.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
    /// protobuf data.
    pub fn decode(
        bytes: ::buffa::bytes::Bytes,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecBaseEncodingErrorOwnedView(::buffa::OwnedView::decode(bytes)?),
        )
    }
    /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
    /// max message size).
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
    /// exceeds the configured limits.
    pub fn decode_with_options(
        bytes: ::buffa::bytes::Bytes,
        opts: &::buffa::DecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecBaseEncodingErrorOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError::MessageTooLarge`] if the
    /// message's encoded size exceeds the 2 GiB protobuf limit, or
    /// another [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::CodecBaseEncodingError,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecBaseEncodingErrorOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`CodecBaseEncodingErrorView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &CodecBaseEncodingErrorView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    ///
    /// Infallible: this type's constructors wire-decode their
    /// buffer, and a view produced by wire decoding always
    /// converts. Delegates to [`::buffa::OwnedView::to_owned_message`],
    /// whose contract also governs handles converted from a raw
    /// [`::buffa::OwnedView`].
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::CodecBaseEncodingError {
        self.0.to_owned_message()
    }
    /// The underlying bytes buffer.
    #[must_use]
    pub fn bytes(&self) -> &::buffa::bytes::Bytes {
        self.0.bytes()
    }
    /// Consume the handle, returning the underlying bytes buffer.
    #[must_use]
    pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
        self.0.into_bytes()
    }
    /// Reason must be one of the CODEC_ERROR_REASON_BASE_* values.
    ///
    /// Field 1: `reason`
    #[must_use]
    pub fn reason(&self) -> ::buffa::EnumValue<super::super::CodecErrorReason> {
        self.0.reborrow().reason
    }
}
impl ::core::convert::From<::buffa::OwnedView<CodecBaseEncodingErrorView<'static>>>
for CodecBaseEncodingErrorOwnedView {
    fn from(inner: ::buffa::OwnedView<CodecBaseEncodingErrorView<'static>>) -> Self {
        CodecBaseEncodingErrorOwnedView(inner)
    }
}
impl ::core::convert::From<CodecBaseEncodingErrorOwnedView>
for ::buffa::OwnedView<CodecBaseEncodingErrorView<'static>> {
    fn from(wrapper: CodecBaseEncodingErrorOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<CodecBaseEncodingErrorView<'static>>>
for CodecBaseEncodingErrorOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<CodecBaseEncodingErrorView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::CodecBaseEncodingError {
    type View<'a> = CodecBaseEncodingErrorView<'a>;
    type ViewHandle = CodecBaseEncodingErrorOwnedView;
}
impl ::serde::Serialize for CodecBaseEncodingErrorOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
/// CodecPemError describes RFC 7468-style PEM armor boundary and body failures.
#[derive(Clone, Debug, Default)]
pub struct CodecPemErrorView<'a> {
    /// Reason must be one of the CODEC_ERROR_REASON_PEM_* values.
    ///
    /// Field 1: `reason`
    pub reason: ::buffa::EnumValue<super::super::CodecErrorReason>,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::buffa::MessageView<'a> for CodecPemErrorView<'a> {
    type Owned = super::super::CodecPemError;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.reason = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(&mut cur)?,
                );
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<super::super::CodecPemError, ::buffa::DecodeError> {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<super::super::CodecPemError, ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecPemError {
            reason: self.reason,
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecPemErrorView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) as u64;
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, buf);
            }
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecPemErrorView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.reason) {
            __map.serialize_entry("reason", &self.reason)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecPemErrorView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecPemErrorView);
::buffa::impl_view_reborrow!(CodecPemErrorView);
/** Self-contained, `'static` owned view of a `CodecPemError` message.

 Wraps [`::buffa::OwnedView`]`<`[`CodecPemErrorView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CodecPemErrorView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct CodecPemErrorOwnedView(::buffa::OwnedView<CodecPemErrorView<'static>>);
impl CodecPemErrorOwnedView {
    /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
    ///
    /// The view borrows directly from the buffer's data; the buffer is
    /// retained inside the returned handle.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
    /// protobuf data.
    pub fn decode(
        bytes: ::buffa::bytes::Bytes,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecPemErrorOwnedView(::buffa::OwnedView::decode(bytes)?),
        )
    }
    /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
    /// max message size).
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
    /// exceeds the configured limits.
    pub fn decode_with_options(
        bytes: ::buffa::bytes::Bytes,
        opts: &::buffa::DecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecPemErrorOwnedView(::buffa::OwnedView::decode_with_options(bytes, opts)?),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError::MessageTooLarge`] if the
    /// message's encoded size exceeds the 2 GiB protobuf limit, or
    /// another [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::CodecPemError,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecPemErrorOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`CodecPemErrorView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &CodecPemErrorView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    ///
    /// Infallible: this type's constructors wire-decode their
    /// buffer, and a view produced by wire decoding always
    /// converts. Delegates to [`::buffa::OwnedView::to_owned_message`],
    /// whose contract also governs handles converted from a raw
    /// [`::buffa::OwnedView`].
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::CodecPemError {
        self.0.to_owned_message()
    }
    /// The underlying bytes buffer.
    #[must_use]
    pub fn bytes(&self) -> &::buffa::bytes::Bytes {
        self.0.bytes()
    }
    /// Consume the handle, returning the underlying bytes buffer.
    #[must_use]
    pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
        self.0.into_bytes()
    }
    /// Reason must be one of the CODEC_ERROR_REASON_PEM_* values.
    ///
    /// Field 1: `reason`
    #[must_use]
    pub fn reason(&self) -> ::buffa::EnumValue<super::super::CodecErrorReason> {
        self.0.reborrow().reason
    }
}
impl ::core::convert::From<::buffa::OwnedView<CodecPemErrorView<'static>>>
for CodecPemErrorOwnedView {
    fn from(inner: ::buffa::OwnedView<CodecPemErrorView<'static>>) -> Self {
        CodecPemErrorOwnedView(inner)
    }
}
impl ::core::convert::From<CodecPemErrorOwnedView>
for ::buffa::OwnedView<CodecPemErrorView<'static>> {
    fn from(wrapper: CodecPemErrorOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<CodecPemErrorView<'static>>>
for CodecPemErrorOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<CodecPemErrorView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::CodecPemError {
    type View<'a> = CodecPemErrorView<'a>;
    type ViewHandle = CodecPemErrorOwnedView;
}
impl ::serde::Serialize for CodecPemErrorOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
/// CodecMultiformatError describes multibase, multicodec, and multikey
/// envelope failures.
#[derive(Clone, Debug, Default)]
pub struct CodecMultiformatErrorView<'a> {
    /// Reason must be one of the CODEC_ERROR_REASON_MULTIFORMAT_* values.
    ///
    /// Field 1: `reason`
    pub reason: ::buffa::EnumValue<super::super::CodecErrorReason>,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::buffa::MessageView<'a> for CodecMultiformatErrorView<'a> {
    type Owned = super::super::CodecMultiformatError;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.reason = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(&mut cur)?,
                );
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecMultiformatError,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecMultiformatError,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecMultiformatError {
            reason: self.reason,
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecMultiformatErrorView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) as u64;
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, buf);
            }
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecMultiformatErrorView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.reason) {
            __map.serialize_entry("reason", &self.reason)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecMultiformatErrorView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecMultiformatErrorView);
::buffa::impl_view_reborrow!(CodecMultiformatErrorView);
/** Self-contained, `'static` owned view of a `CodecMultiformatError` message.

 Wraps [`::buffa::OwnedView`]`<`[`CodecMultiformatErrorView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CodecMultiformatErrorView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct CodecMultiformatErrorOwnedView(
    ::buffa::OwnedView<CodecMultiformatErrorView<'static>>,
);
impl CodecMultiformatErrorOwnedView {
    /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
    ///
    /// The view borrows directly from the buffer's data; the buffer is
    /// retained inside the returned handle.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
    /// protobuf data.
    pub fn decode(
        bytes: ::buffa::bytes::Bytes,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecMultiformatErrorOwnedView(::buffa::OwnedView::decode(bytes)?),
        )
    }
    /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
    /// max message size).
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
    /// exceeds the configured limits.
    pub fn decode_with_options(
        bytes: ::buffa::bytes::Bytes,
        opts: &::buffa::DecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecMultiformatErrorOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError::MessageTooLarge`] if the
    /// message's encoded size exceeds the 2 GiB protobuf limit, or
    /// another [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::CodecMultiformatError,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecMultiformatErrorOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`CodecMultiformatErrorView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &CodecMultiformatErrorView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    ///
    /// Infallible: this type's constructors wire-decode their
    /// buffer, and a view produced by wire decoding always
    /// converts. Delegates to [`::buffa::OwnedView::to_owned_message`],
    /// whose contract also governs handles converted from a raw
    /// [`::buffa::OwnedView`].
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::CodecMultiformatError {
        self.0.to_owned_message()
    }
    /// The underlying bytes buffer.
    #[must_use]
    pub fn bytes(&self) -> &::buffa::bytes::Bytes {
        self.0.bytes()
    }
    /// Consume the handle, returning the underlying bytes buffer.
    #[must_use]
    pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
        self.0.into_bytes()
    }
    /// Reason must be one of the CODEC_ERROR_REASON_MULTIFORMAT_* values.
    ///
    /// Field 1: `reason`
    #[must_use]
    pub fn reason(&self) -> ::buffa::EnumValue<super::super::CodecErrorReason> {
        self.0.reborrow().reason
    }
}
impl ::core::convert::From<::buffa::OwnedView<CodecMultiformatErrorView<'static>>>
for CodecMultiformatErrorOwnedView {
    fn from(inner: ::buffa::OwnedView<CodecMultiformatErrorView<'static>>) -> Self {
        CodecMultiformatErrorOwnedView(inner)
    }
}
impl ::core::convert::From<CodecMultiformatErrorOwnedView>
for ::buffa::OwnedView<CodecMultiformatErrorView<'static>> {
    fn from(wrapper: CodecMultiformatErrorOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<CodecMultiformatErrorView<'static>>>
for CodecMultiformatErrorOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<CodecMultiformatErrorView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::CodecMultiformatError {
    type View<'a> = CodecMultiformatErrorView<'a>;
    type ViewHandle = CodecMultiformatErrorOwnedView;
}
impl ::serde::Serialize for CodecMultiformatErrorOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
/// CodecCanonicalizationError describes CBOR, DAG-CBOR, JCS, and JSON
/// canonicalization failures.
#[derive(Clone, Debug, Default)]
pub struct CodecCanonicalizationErrorView<'a> {
    /// Reason must be one of the CODEC_ERROR_REASON_CANONICAL_* values.
    ///
    /// Field 1: `reason`
    pub reason: ::buffa::EnumValue<super::super::CodecErrorReason>,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::buffa::MessageView<'a> for CodecCanonicalizationErrorView<'a> {
    type Owned = super::super::CodecCanonicalizationError;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.reason = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(&mut cur)?,
                );
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<
        super::super::CodecCanonicalizationError,
        ::buffa::DecodeError,
    > {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<
        super::super::CodecCanonicalizationError,
        ::buffa::DecodeError,
    > {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecCanonicalizationError {
            reason: self.reason,
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecCanonicalizationErrorView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) as u64;
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, buf);
            }
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecCanonicalizationErrorView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.reason) {
            __map.serialize_entry("reason", &self.reason)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecCanonicalizationErrorView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecCanonicalizationErrorView);
::buffa::impl_view_reborrow!(CodecCanonicalizationErrorView);
/** Self-contained, `'static` owned view of a `CodecCanonicalizationError` message.

 Wraps [`::buffa::OwnedView`]`<`[`CodecCanonicalizationErrorView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CodecCanonicalizationErrorView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct CodecCanonicalizationErrorOwnedView(
    ::buffa::OwnedView<CodecCanonicalizationErrorView<'static>>,
);
impl CodecCanonicalizationErrorOwnedView {
    /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
    ///
    /// The view borrows directly from the buffer's data; the buffer is
    /// retained inside the returned handle.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
    /// protobuf data.
    pub fn decode(
        bytes: ::buffa::bytes::Bytes,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecCanonicalizationErrorOwnedView(::buffa::OwnedView::decode(bytes)?),
        )
    }
    /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
    /// max message size).
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
    /// exceeds the configured limits.
    pub fn decode_with_options(
        bytes: ::buffa::bytes::Bytes,
        opts: &::buffa::DecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecCanonicalizationErrorOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError::MessageTooLarge`] if the
    /// message's encoded size exceeds the 2 GiB protobuf limit, or
    /// another [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::CodecCanonicalizationError,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecCanonicalizationErrorOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`CodecCanonicalizationErrorView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &CodecCanonicalizationErrorView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    ///
    /// Infallible: this type's constructors wire-decode their
    /// buffer, and a view produced by wire decoding always
    /// converts. Delegates to [`::buffa::OwnedView::to_owned_message`],
    /// whose contract also governs handles converted from a raw
    /// [`::buffa::OwnedView`].
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::CodecCanonicalizationError {
        self.0.to_owned_message()
    }
    /// The underlying bytes buffer.
    #[must_use]
    pub fn bytes(&self) -> &::buffa::bytes::Bytes {
        self.0.bytes()
    }
    /// Consume the handle, returning the underlying bytes buffer.
    #[must_use]
    pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
        self.0.into_bytes()
    }
    /// Reason must be one of the CODEC_ERROR_REASON_CANONICAL_* values.
    ///
    /// Field 1: `reason`
    #[must_use]
    pub fn reason(&self) -> ::buffa::EnumValue<super::super::CodecErrorReason> {
        self.0.reborrow().reason
    }
}
impl ::core::convert::From<::buffa::OwnedView<CodecCanonicalizationErrorView<'static>>>
for CodecCanonicalizationErrorOwnedView {
    fn from(inner: ::buffa::OwnedView<CodecCanonicalizationErrorView<'static>>) -> Self {
        CodecCanonicalizationErrorOwnedView(inner)
    }
}
impl ::core::convert::From<CodecCanonicalizationErrorOwnedView>
for ::buffa::OwnedView<CodecCanonicalizationErrorView<'static>> {
    fn from(wrapper: CodecCanonicalizationErrorOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<CodecCanonicalizationErrorView<'static>>>
for CodecCanonicalizationErrorOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<CodecCanonicalizationErrorView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::CodecCanonicalizationError {
    type View<'a> = CodecCanonicalizationErrorView<'a>;
    type ViewHandle = CodecCanonicalizationErrorOwnedView;
}
impl ::serde::Serialize for CodecCanonicalizationErrorOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
/// CodecBackendError describes serialization, protobuf, dispatch, FFI, WASM,
/// and internal failures that are not safe to expose as backend exception text.
#[derive(Clone, Debug, Default)]
pub struct CodecBackendErrorView<'a> {
    /// Reason must be one of the CODEC_ERROR_REASON_BACKEND_* values.
    ///
    /// Field 1: `reason`
    pub reason: ::buffa::EnumValue<super::super::CodecErrorReason>,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::buffa::MessageView<'a> for CodecBackendErrorView<'a> {
    type Owned = super::super::CodecBackendError;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.reason = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(&mut cur)?,
                );
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<super::super::CodecBackendError, ::buffa::DecodeError> {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<super::super::CodecBackendError, ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecBackendError {
            reason: self.reason,
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecBackendErrorView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) as u64;
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, buf);
            }
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecBackendErrorView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.reason) {
            __map.serialize_entry("reason", &self.reason)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecBackendErrorView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecBackendErrorView);
::buffa::impl_view_reborrow!(CodecBackendErrorView);
/** Self-contained, `'static` owned view of a `CodecBackendError` message.

 Wraps [`::buffa::OwnedView`]`<`[`CodecBackendErrorView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CodecBackendErrorView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct CodecBackendErrorOwnedView(
    ::buffa::OwnedView<CodecBackendErrorView<'static>>,
);
impl CodecBackendErrorOwnedView {
    /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
    ///
    /// The view borrows directly from the buffer's data; the buffer is
    /// retained inside the returned handle.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
    /// protobuf data.
    pub fn decode(
        bytes: ::buffa::bytes::Bytes,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecBackendErrorOwnedView(::buffa::OwnedView::decode(bytes)?),
        )
    }
    /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
    /// max message size).
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
    /// exceeds the configured limits.
    pub fn decode_with_options(
        bytes: ::buffa::bytes::Bytes,
        opts: &::buffa::DecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecBackendErrorOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError::MessageTooLarge`] if the
    /// message's encoded size exceeds the 2 GiB protobuf limit, or
    /// another [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::CodecBackendError,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecBackendErrorOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`CodecBackendErrorView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &CodecBackendErrorView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    ///
    /// Infallible: this type's constructors wire-decode their
    /// buffer, and a view produced by wire decoding always
    /// converts. Delegates to [`::buffa::OwnedView::to_owned_message`],
    /// whose contract also governs handles converted from a raw
    /// [`::buffa::OwnedView`].
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::CodecBackendError {
        self.0.to_owned_message()
    }
    /// The underlying bytes buffer.
    #[must_use]
    pub fn bytes(&self) -> &::buffa::bytes::Bytes {
        self.0.bytes()
    }
    /// Consume the handle, returning the underlying bytes buffer.
    #[must_use]
    pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
        self.0.into_bytes()
    }
    /// Reason must be one of the CODEC_ERROR_REASON_BACKEND_* values.
    ///
    /// Field 1: `reason`
    #[must_use]
    pub fn reason(&self) -> ::buffa::EnumValue<super::super::CodecErrorReason> {
        self.0.reborrow().reason
    }
}
impl ::core::convert::From<::buffa::OwnedView<CodecBackendErrorView<'static>>>
for CodecBackendErrorOwnedView {
    fn from(inner: ::buffa::OwnedView<CodecBackendErrorView<'static>>) -> Self {
        CodecBackendErrorOwnedView(inner)
    }
}
impl ::core::convert::From<CodecBackendErrorOwnedView>
for ::buffa::OwnedView<CodecBackendErrorView<'static>> {
    fn from(wrapper: CodecBackendErrorOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<CodecBackendErrorView<'static>>>
for CodecBackendErrorOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<CodecBackendErrorView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::CodecBackendError {
    type View<'a> = CodecBackendErrorView<'a>;
    type ViewHandle = CodecBackendErrorOwnedView;
}
impl ::serde::Serialize for CodecBackendErrorOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
/// CodecBoundaryError describes malformed, oversized, or incomplete caller
/// requests. These failures are not backend failures and never contain parser
/// or runtime exception text.
#[derive(Clone, Debug, Default)]
pub struct CodecBoundaryErrorView<'a> {
    /// Reason must be one of the CODEC_ERROR_REASON_BOUNDARY_* values.
    ///
    /// Field 1: `reason`
    pub reason: ::buffa::EnumValue<super::super::CodecErrorReason>,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ::buffa::MessageView<'a> for CodecBoundaryErrorView<'a> {
    type Owned = super::super::CodecBoundaryError;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let __limit = ::core::cell::Cell::new(::buffa::DEFAULT_UNKNOWN_FIELD_LIMIT);
        let __elem = ::core::cell::Cell::new(::buffa::DEFAULT_ELEMENT_MEMORY_LIMIT);
        <Self as ::buffa::MessageView>::decode_view_ctx(
            buf,
            ::buffa::DecodeContext::new(::buffa::RECURSION_LIMIT, &__limit)
                .with_element_memory(&__elem),
        )
    }
    fn decode_view_with_ctx(
        buf: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        <Self as ::buffa::MessageView>::decode_view_ctx(buf, ctx)
    }
    #[inline]
    fn merge_view_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        cur: &'a [u8],
        before_tag: &'a [u8],
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<&'a [u8], ::buffa::DecodeError> {
        let _ = ctx;
        #[allow(unused_variables)]
        let view = self;
        let mut cur = cur;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                view.reason = ::buffa::EnumValue::from(
                    ::buffa::types::decode_int32(&mut cur)?,
                );
            }
            _ => {
                ::buffa::encoding::skip_field_depth(tag, &mut cur, ctx.depth())?;
                let span_len = before_tag.len() - cur.len();
                view.__buffa_unknown_fields.push_record(before_tag, span_len, ctx)?;
            }
        }
        ::core::result::Result::Ok(cur)
    }
    fn to_owned_message(
        &self,
    ) -> ::core::result::Result<super::super::CodecBoundaryError, ::buffa::DecodeError> {
        self.to_owned_from_source(None)
    }
    #[allow(clippy::useless_conversion, clippy::needless_update)]
    fn to_owned_from_source(
        &self,
        __buffa_src: ::core::option::Option<&::buffa::bytes::Bytes>,
    ) -> ::core::result::Result<super::super::CodecBoundaryError, ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        ::core::result::Result::Ok(super::super::CodecBoundaryError {
            reason: self.reason,
            __buffa_unknown_fields: self.__buffa_unknown_fields.to_owned()?.into(),
            ..::core::default::Default::default()
        })
    }
}
impl<'a> ::buffa::ViewEncode<'a> for CodecBoundaryErrorView<'a> {
    #[allow(clippy::needless_borrow, clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                size += 1u64 + ::buffa::types::int32_encoded_len(val) as u64;
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        {
            let val = self.reason.to_i32();
            if val != 0 {
                ::buffa::types::put_int32_field(1u32, val, buf);
            }
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
}
/// Serializes this view as protobuf JSON.
///
/// Implicit-presence fields with default values are omitted, `required`
/// fields are always emitted, explicit-presence (`optional`) fields are
/// emitted only when set, bytes fields are base64-encoded, and enum
/// values are their proto name strings.
///
/// This impl uses `serialize_map(None)` because the number of emitted
/// fields depends on default-omission rules; serializers that require
/// known map lengths (e.g. `bincode`) will return a runtime error.
/// Use the owned message type for those formats.
impl<'__a> ::serde::Serialize for CodecBoundaryErrorView<'__a> {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        use ::serde::ser::SerializeMap as _;
        let mut __map = __s.serialize_map(::core::option::Option::None)?;
        if !::buffa::json_helpers::skip_if::is_default_enum_value(&self.reason) {
            __map.serialize_entry("reason", &self.reason)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for CodecBoundaryErrorView<'a> {
    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";
}
::buffa::impl_default_view_instance!(CodecBoundaryErrorView);
::buffa::impl_view_reborrow!(CodecBoundaryErrorView);
/** Self-contained, `'static` owned view of a `CodecBoundaryError` message.

 Wraps [`::buffa::OwnedView`]`<`[`CodecBoundaryErrorView`]`<'static>>`: the decoded view and the [`::buffa::bytes::Bytes`] buffer it borrows from travel together, so the handle is `'static` and `Send + Sync` — suitable for async handlers, spawned tasks, and anywhere a `'static` bound is required.

 Field accessors return borrows tied to `&self`. Use [`Self::view`] to get the full [`CodecBoundaryErrorView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct CodecBoundaryErrorOwnedView(
    ::buffa::OwnedView<CodecBoundaryErrorView<'static>>,
);
impl CodecBoundaryErrorOwnedView {
    /// Decode an owned view from a [`::buffa::bytes::Bytes`] buffer.
    ///
    /// The view borrows directly from the buffer's data; the buffer is
    /// retained inside the returned handle.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer contains invalid
    /// protobuf data.
    pub fn decode(
        bytes: ::buffa::bytes::Bytes,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecBoundaryErrorOwnedView(::buffa::OwnedView::decode(bytes)?),
        )
    }
    /// Decode with custom [`::buffa::DecodeOptions`] (recursion limit,
    /// max message size).
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the buffer is invalid or
    /// exceeds the configured limits.
    pub fn decode_with_options(
        bytes: ::buffa::bytes::Bytes,
        opts: &::buffa::DecodeOptions,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecBoundaryErrorOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError::MessageTooLarge`] if the
    /// message's encoded size exceeds the 2 GiB protobuf limit, or
    /// another [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::CodecBoundaryError,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            CodecBoundaryErrorOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`CodecBoundaryErrorView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &CodecBoundaryErrorView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    ///
    /// Infallible: this type's constructors wire-decode their
    /// buffer, and a view produced by wire decoding always
    /// converts. Delegates to [`::buffa::OwnedView::to_owned_message`],
    /// whose contract also governs handles converted from a raw
    /// [`::buffa::OwnedView`].
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::CodecBoundaryError {
        self.0.to_owned_message()
    }
    /// The underlying bytes buffer.
    #[must_use]
    pub fn bytes(&self) -> &::buffa::bytes::Bytes {
        self.0.bytes()
    }
    /// Consume the handle, returning the underlying bytes buffer.
    #[must_use]
    pub fn into_bytes(self) -> ::buffa::bytes::Bytes {
        self.0.into_bytes()
    }
    /// Reason must be one of the CODEC_ERROR_REASON_BOUNDARY_* values.
    ///
    /// Field 1: `reason`
    #[must_use]
    pub fn reason(&self) -> ::buffa::EnumValue<super::super::CodecErrorReason> {
        self.0.reborrow().reason
    }
}
impl ::core::convert::From<::buffa::OwnedView<CodecBoundaryErrorView<'static>>>
for CodecBoundaryErrorOwnedView {
    fn from(inner: ::buffa::OwnedView<CodecBoundaryErrorView<'static>>) -> Self {
        CodecBoundaryErrorOwnedView(inner)
    }
}
impl ::core::convert::From<CodecBoundaryErrorOwnedView>
for ::buffa::OwnedView<CodecBoundaryErrorView<'static>> {
    fn from(wrapper: CodecBoundaryErrorOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<CodecBoundaryErrorView<'static>>>
for CodecBoundaryErrorOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<CodecBoundaryErrorView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::CodecBoundaryError {
    type View<'a> = CodecBoundaryErrorView<'a>;
    type ViewHandle = CodecBoundaryErrorOwnedView;
}
impl ::serde::Serialize for CodecBoundaryErrorOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}