connectrpc-reflection 0.7.0

// @generated by buffa-codegen. DO NOT EDIT.
// source: grpc/reflection/v1alpha/reflection.proto

/// The message sent by the client when calling ServerReflectionInfo method.
#[derive(Clone, Debug, Default)]
pub struct ServerReflectionRequestView<'a> {
    /// Field 1: `host`
    pub host: &'a str,
    pub message_request: ::core::option::Option<
        super::super::__buffa::view::oneof::server_reflection_request::MessageRequest<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ServerReflectionRequestView<'a> {
    /// Decode from `buf`, enforcing a recursion depth limit for nested messages.
    ///
    /// Called by [`::buffa::MessageView::decode_view`] with [`::buffa::RECURSION_LIMIT`]
    /// and by generated sub-message decode arms with `depth - 1`.
    ///
    /// **Not part of the public API.** Named with a leading underscore to
    /// signal that it is for generated-code use only.
    #[doc(hidden)]
    pub fn _decode_depth(
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let mut view = Self::default();
        view._merge_into_view(buf, depth)?;
        ::core::result::Result::Ok(view)
    }
    /// Merge fields from `buf` into this view (proto merge semantics).
    ///
    /// Repeated fields append; singular fields last-wins; singular
    /// MESSAGE fields merge recursively. Used by sub-message decode
    /// arms when the same field appears multiple times on the wire.
    ///
    /// **Not part of the public API.**
    #[doc(hidden)]
    pub fn _merge_into_view(
        &mut self,
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        let _ = depth;
        #[allow(unused_variables)]
        let view = self;
        let mut cur: &'a [u8] = buf;
        while !cur.is_empty() {
            let before_tag = cur;
            let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
            match tag.field_number() {
                1u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 1u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    view.host = ::buffa::types::borrow_str(&mut cur)?;
                }
                3u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 3u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    view.message_request = Some(
                        super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::FileByFilename(
                            ::buffa::types::borrow_str(&mut cur)?,
                        ),
                    );
                }
                4u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 4u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    view.message_request = Some(
                        super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::FileContainingSymbol(
                            ::buffa::types::borrow_str(&mut cur)?,
                        ),
                    );
                }
                5u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 5u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    if depth == 0 {
                        return Err(::buffa::DecodeError::RecursionLimitExceeded);
                    }
                    let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                    if let Some(
                        super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::FileContainingExtension(
                            ref mut existing,
                        ),
                    ) = view.message_request
                    {
                        existing._merge_into_view(sub, depth - 1)?;
                    } else {
                        view.message_request = Some(
                            super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::FileContainingExtension(
                                ::buffa::alloc::boxed::Box::new(
                                    super::super::__buffa::view::ExtensionRequestView::_decode_depth(
                                        sub,
                                        depth - 1,
                                    )?,
                                ),
                            ),
                        );
                    }
                }
                6u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 6u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    view.message_request = Some(
                        super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::AllExtensionNumbersOfType(
                            ::buffa::types::borrow_str(&mut cur)?,
                        ),
                    );
                }
                7u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 7u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    view.message_request = Some(
                        super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::ListServices(
                            ::buffa::types::borrow_str(&mut cur)?,
                        ),
                    );
                }
                _ => {
                    ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
                    let span_len = before_tag.len() - cur.len();
                    view.__buffa_unknown_fields.push_raw(&before_tag[..span_len]);
                }
            }
        }
        ::core::result::Result::Ok(())
    }
}
impl<'a> ::buffa::MessageView<'a> for ServerReflectionRequestView<'a> {
    type Owned = super::super::ServerReflectionRequest;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
    }
    fn decode_view_with_limit(
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        Self::_decode_depth(buf, depth)
    }
    fn to_owned_message(&self) -> super::super::ServerReflectionRequest {
        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>,
    ) -> super::super::ServerReflectionRequest {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        super::super::ServerReflectionRequest {
            host: self.host.to_string(),
            message_request: self
                .message_request
                .as_ref()
                .map(|v| match v {
                    super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::FileByFilename(
                        v,
                    ) => {
                        super::super::__buffa::oneof::server_reflection_request::MessageRequest::FileByFilename(
                            v.to_string(),
                        )
                    }
                    super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::FileContainingSymbol(
                        v,
                    ) => {
                        super::super::__buffa::oneof::server_reflection_request::MessageRequest::FileContainingSymbol(
                            v.to_string(),
                        )
                    }
                    super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::FileContainingExtension(
                        v,
                    ) => {
                        super::super::__buffa::oneof::server_reflection_request::MessageRequest::FileContainingExtension(
                            ::buffa::alloc::boxed::Box::new(
                                v.to_owned_from_source(__buffa_src),
                            ),
                        )
                    }
                    super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::AllExtensionNumbersOfType(
                        v,
                    ) => {
                        super::super::__buffa::oneof::server_reflection_request::MessageRequest::AllExtensionNumbersOfType(
                            v.to_string(),
                        )
                    }
                    super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::ListServices(
                        v,
                    ) => {
                        super::super::__buffa::oneof::server_reflection_request::MessageRequest::ListServices(
                            v.to_string(),
                        )
                    }
                }),
            __buffa_unknown_fields: self
                .__buffa_unknown_fields
                .to_owned()
                .unwrap_or_default()
                .into(),
            ..::core::default::Default::default()
        }
    }
}
impl<'a> ::buffa::ViewEncode<'a> for ServerReflectionRequestView<'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 = 0u32;
        if !self.host.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.host) as u32;
        }
        if let ::core::option::Option::Some(ref v) = self.message_request {
            match v {
                super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::FileByFilename(
                    x,
                ) => {
                    size += 1u32 + ::buffa::types::string_encoded_len(x) as u32;
                }
                super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::FileContainingSymbol(
                    x,
                ) => {
                    size += 1u32 + ::buffa::types::string_encoded_len(x) as u32;
                }
                super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::FileContainingExtension(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
                super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::AllExtensionNumbersOfType(
                    x,
                ) => {
                    size += 1u32 + ::buffa::types::string_encoded_len(x) as u32;
                }
                super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::ListServices(
                    x,
                ) => {
                    size += 1u32 + ::buffa::types::string_encoded_len(x) as u32;
                }
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.host.is_empty() {
            ::buffa::encoding::Tag::new(
                    1u32,
                    ::buffa::encoding::WireType::LengthDelimited,
                )
                .encode(buf);
            ::buffa::types::encode_string(&self.host, buf);
        }
        if let ::core::option::Option::Some(ref v) = self.message_request {
            match v {
                super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::FileByFilename(
                    x,
                ) => {
                    ::buffa::encoding::Tag::new(
                            3u32,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )
                        .encode(buf);
                    ::buffa::types::encode_string(x, buf);
                }
                super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::FileContainingSymbol(
                    x,
                ) => {
                    ::buffa::encoding::Tag::new(
                            4u32,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )
                        .encode(buf);
                    ::buffa::types::encode_string(x, buf);
                }
                super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::FileContainingExtension(
                    x,
                ) => {
                    ::buffa::encoding::Tag::new(
                            5u32,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )
                        .encode(buf);
                    ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::AllExtensionNumbersOfType(
                    x,
                ) => {
                    ::buffa::encoding::Tag::new(
                            6u32,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )
                        .encode(buf);
                    ::buffa::types::encode_string(x, buf);
                }
                super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::ListServices(
                    x,
                ) => {
                    ::buffa::encoding::Tag::new(
                            7u32,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )
                        .encode(buf);
                    ::buffa::types::encode_string(x, 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 ServerReflectionRequestView<'__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.host) {
            __map.serialize_entry("host", self.host)?;
        }
        if let ::core::option::Option::Some(ref __ov) = self.message_request {
            match __ov {
                super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::FileByFilename(
                    v,
                ) => {
                    __map.serialize_entry("fileByFilename", v)?;
                }
                super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::FileContainingSymbol(
                    v,
                ) => {
                    __map.serialize_entry("fileContainingSymbol", v)?;
                }
                super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::FileContainingExtension(
                    v,
                ) => {
                    __map.serialize_entry("fileContainingExtension", v)?;
                }
                super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::AllExtensionNumbersOfType(
                    v,
                ) => {
                    __map.serialize_entry("allExtensionNumbersOfType", v)?;
                }
                super::super::__buffa::view::oneof::server_reflection_request::MessageRequest::ListServices(
                    v,
                ) => {
                    __map.serialize_entry("listServices", v)?;
                }
            }
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for ServerReflectionRequestView<'a> {
    const PACKAGE: &'static str = "grpc.reflection.v1alpha";
    const NAME: &'static str = "ServerReflectionRequest";
    const FULL_NAME: &'static str = "grpc.reflection.v1alpha.ServerReflectionRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ServerReflectionRequest";
}
impl<'v> ::buffa::DefaultViewInstance for ServerReflectionRequestView<'v> {
    fn default_view_instance<'a>() -> &'a Self
    where
        Self: 'a,
    {
        static VALUE: ::buffa::__private::OnceBox<
            ServerReflectionRequestView<'static>,
        > = ::buffa::__private::OnceBox::new();
        VALUE
            .get_or_init(|| ::buffa::alloc::boxed::Box::new(
                <ServerReflectionRequestView<'static>>::default(),
            ))
    }
}
impl ::buffa::ViewReborrow for ServerReflectionRequestView<'static> {
    type Reborrowed<'b> = ServerReflectionRequestView<'b>;
    fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
        this
    }
}
/** Self-contained, `'static` owned view of a `ServerReflectionRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`ServerReflectionRequestView`]`<'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 [`ServerReflectionRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct ServerReflectionRequestOwnedView(
    ::buffa::OwnedView<ServerReflectionRequestView<'static>>,
);
impl ServerReflectionRequestOwnedView {
    /// 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(
            ServerReflectionRequestOwnedView(::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(
            ServerReflectionRequestOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::ServerReflectionRequest,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            ServerReflectionRequestOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`ServerReflectionRequestView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &ServerReflectionRequestView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::ServerReflectionRequest {
        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: `host`
    #[must_use]
    pub fn host(&self) -> &'_ str {
        self.0.reborrow().host
    }
    /// Oneof `message_request`.
    #[must_use]
    pub fn message_request(
        &self,
    ) -> ::core::option::Option<
        &super::super::__buffa::view::oneof::server_reflection_request::MessageRequest<
            '_,
        >,
    > {
        self.0.reborrow().message_request.as_ref()
    }
}
impl ::core::convert::From<::buffa::OwnedView<ServerReflectionRequestView<'static>>>
for ServerReflectionRequestOwnedView {
    fn from(inner: ::buffa::OwnedView<ServerReflectionRequestView<'static>>) -> Self {
        ServerReflectionRequestOwnedView(inner)
    }
}
impl ::core::convert::From<ServerReflectionRequestOwnedView>
for ::buffa::OwnedView<ServerReflectionRequestView<'static>> {
    fn from(wrapper: ServerReflectionRequestOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<ServerReflectionRequestView<'static>>>
for ServerReflectionRequestOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<ServerReflectionRequestView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::ServerReflectionRequest {
    type View<'a> = ServerReflectionRequestView<'a>;
    type ViewHandle = ServerReflectionRequestOwnedView;
}
impl ::serde::Serialize for ServerReflectionRequestOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
/// The type name and extension number sent by the client when requesting
/// file_containing_extension.
#[derive(Clone, Debug, Default)]
pub struct ExtensionRequestView<'a> {
    /// Fully-qualified type name. The format should be \<package\>.\<type\>
    ///
    /// Field 1: `containing_type`
    pub containing_type: &'a str,
    /// Field 2: `extension_number`
    pub extension_number: i32,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ExtensionRequestView<'a> {
    /// Decode from `buf`, enforcing a recursion depth limit for nested messages.
    ///
    /// Called by [`::buffa::MessageView::decode_view`] with [`::buffa::RECURSION_LIMIT`]
    /// and by generated sub-message decode arms with `depth - 1`.
    ///
    /// **Not part of the public API.** Named with a leading underscore to
    /// signal that it is for generated-code use only.
    #[doc(hidden)]
    pub fn _decode_depth(
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let mut view = Self::default();
        view._merge_into_view(buf, depth)?;
        ::core::result::Result::Ok(view)
    }
    /// Merge fields from `buf` into this view (proto merge semantics).
    ///
    /// Repeated fields append; singular fields last-wins; singular
    /// MESSAGE fields merge recursively. Used by sub-message decode
    /// arms when the same field appears multiple times on the wire.
    ///
    /// **Not part of the public API.**
    #[doc(hidden)]
    pub fn _merge_into_view(
        &mut self,
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        let _ = depth;
        #[allow(unused_variables)]
        let view = self;
        let mut cur: &'a [u8] = buf;
        while !cur.is_empty() {
            let before_tag = cur;
            let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
            match tag.field_number() {
                1u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 1u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    view.containing_type = ::buffa::types::borrow_str(&mut cur)?;
                }
                2u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::Varint {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 2u32,
                            expected: 0u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    view.extension_number = ::buffa::types::decode_int32(&mut cur)?;
                }
                _ => {
                    ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
                    let span_len = before_tag.len() - cur.len();
                    view.__buffa_unknown_fields.push_raw(&before_tag[..span_len]);
                }
            }
        }
        ::core::result::Result::Ok(())
    }
}
impl<'a> ::buffa::MessageView<'a> for ExtensionRequestView<'a> {
    type Owned = super::super::ExtensionRequest;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
    }
    fn decode_view_with_limit(
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        Self::_decode_depth(buf, depth)
    }
    fn to_owned_message(&self) -> super::super::ExtensionRequest {
        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>,
    ) -> super::super::ExtensionRequest {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        super::super::ExtensionRequest {
            containing_type: self.containing_type.to_string(),
            extension_number: self.extension_number,
            __buffa_unknown_fields: self
                .__buffa_unknown_fields
                .to_owned()
                .unwrap_or_default()
                .into(),
            ..::core::default::Default::default()
        }
    }
}
impl<'a> ::buffa::ViewEncode<'a> for ExtensionRequestView<'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 = 0u32;
        if !self.containing_type.is_empty() {
            size
                += 1u32
                    + ::buffa::types::string_encoded_len(&self.containing_type) as u32;
        }
        if self.extension_number != 0i32 {
            size
                += 1u32
                    + ::buffa::types::int32_encoded_len(self.extension_number) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.containing_type.is_empty() {
            ::buffa::encoding::Tag::new(
                    1u32,
                    ::buffa::encoding::WireType::LengthDelimited,
                )
                .encode(buf);
            ::buffa::types::encode_string(&self.containing_type, buf);
        }
        if self.extension_number != 0i32 {
            ::buffa::encoding::Tag::new(2u32, ::buffa::encoding::WireType::Varint)
                .encode(buf);
            ::buffa::types::encode_int32(self.extension_number, 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 ExtensionRequestView<'__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.containing_type) {
            __map.serialize_entry("containingType", self.containing_type)?;
        }
        if !::buffa::json_helpers::skip_if::is_zero_i32(&self.extension_number) {
            struct _W(i32);
            impl ::serde::Serialize for _W {
                fn serialize<__S: ::serde::Serializer>(
                    &self,
                    __s: __S,
                ) -> ::core::result::Result<__S::Ok, __S::Error> {
                    ::buffa::json_helpers::int32::serialize(&self.0, __s)
                }
            }
            __map.serialize_entry("extensionNumber", &_W(self.extension_number))?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for ExtensionRequestView<'a> {
    const PACKAGE: &'static str = "grpc.reflection.v1alpha";
    const NAME: &'static str = "ExtensionRequest";
    const FULL_NAME: &'static str = "grpc.reflection.v1alpha.ExtensionRequest";
    const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ExtensionRequest";
}
impl<'v> ::buffa::DefaultViewInstance for ExtensionRequestView<'v> {
    fn default_view_instance<'a>() -> &'a Self
    where
        Self: 'a,
    {
        static VALUE: ::buffa::__private::OnceBox<ExtensionRequestView<'static>> = ::buffa::__private::OnceBox::new();
        VALUE
            .get_or_init(|| ::buffa::alloc::boxed::Box::new(
                <ExtensionRequestView<'static>>::default(),
            ))
    }
}
impl ::buffa::ViewReborrow for ExtensionRequestView<'static> {
    type Reborrowed<'b> = ExtensionRequestView<'b>;
    fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
        this
    }
}
/** Self-contained, `'static` owned view of a `ExtensionRequest` message.

 Wraps [`::buffa::OwnedView`]`<`[`ExtensionRequestView`]`<'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 [`ExtensionRequestView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct ExtensionRequestOwnedView(::buffa::OwnedView<ExtensionRequestView<'static>>);
impl ExtensionRequestOwnedView {
    /// 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(
            ExtensionRequestOwnedView(::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(
            ExtensionRequestOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::ExtensionRequest,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            ExtensionRequestOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`ExtensionRequestView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &ExtensionRequestView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::ExtensionRequest {
        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()
    }
    /// Fully-qualified type name. The format should be \<package\>.\<type\>
    ///
    /// Field 1: `containing_type`
    #[must_use]
    pub fn containing_type(&self) -> &'_ str {
        self.0.reborrow().containing_type
    }
    /// Field 2: `extension_number`
    #[must_use]
    pub fn extension_number(&self) -> i32 {
        self.0.reborrow().extension_number
    }
}
impl ::core::convert::From<::buffa::OwnedView<ExtensionRequestView<'static>>>
for ExtensionRequestOwnedView {
    fn from(inner: ::buffa::OwnedView<ExtensionRequestView<'static>>) -> Self {
        ExtensionRequestOwnedView(inner)
    }
}
impl ::core::convert::From<ExtensionRequestOwnedView>
for ::buffa::OwnedView<ExtensionRequestView<'static>> {
    fn from(wrapper: ExtensionRequestOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<ExtensionRequestView<'static>>>
for ExtensionRequestOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<ExtensionRequestView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::ExtensionRequest {
    type View<'a> = ExtensionRequestView<'a>;
    type ViewHandle = ExtensionRequestOwnedView;
}
impl ::serde::Serialize for ExtensionRequestOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
/// The message sent by the server to answer ServerReflectionInfo method.
#[derive(Clone, Debug, Default)]
pub struct ServerReflectionResponseView<'a> {
    /// Field 1: `valid_host`
    pub valid_host: &'a str,
    /// Field 2: `original_request`
    pub original_request: ::buffa::MessageFieldView<
        super::super::__buffa::view::ServerReflectionRequestView<'a>,
    >,
    pub message_response: ::core::option::Option<
        super::super::__buffa::view::oneof::server_reflection_response::MessageResponse<
            'a,
        >,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ServerReflectionResponseView<'a> {
    /// Decode from `buf`, enforcing a recursion depth limit for nested messages.
    ///
    /// Called by [`::buffa::MessageView::decode_view`] with [`::buffa::RECURSION_LIMIT`]
    /// and by generated sub-message decode arms with `depth - 1`.
    ///
    /// **Not part of the public API.** Named with a leading underscore to
    /// signal that it is for generated-code use only.
    #[doc(hidden)]
    pub fn _decode_depth(
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let mut view = Self::default();
        view._merge_into_view(buf, depth)?;
        ::core::result::Result::Ok(view)
    }
    /// Merge fields from `buf` into this view (proto merge semantics).
    ///
    /// Repeated fields append; singular fields last-wins; singular
    /// MESSAGE fields merge recursively. Used by sub-message decode
    /// arms when the same field appears multiple times on the wire.
    ///
    /// **Not part of the public API.**
    #[doc(hidden)]
    pub fn _merge_into_view(
        &mut self,
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        let _ = depth;
        #[allow(unused_variables)]
        let view = self;
        let mut cur: &'a [u8] = buf;
        while !cur.is_empty() {
            let before_tag = cur;
            let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
            match tag.field_number() {
                1u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 1u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    view.valid_host = ::buffa::types::borrow_str(&mut cur)?;
                }
                2u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 2u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    if depth == 0 {
                        return Err(::buffa::DecodeError::RecursionLimitExceeded);
                    }
                    let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                    match view.original_request.as_mut() {
                        Some(existing) => existing._merge_into_view(sub, depth - 1)?,
                        None => {
                            view.original_request = ::buffa::MessageFieldView::set(
                                super::super::__buffa::view::ServerReflectionRequestView::_decode_depth(
                                    sub,
                                    depth - 1,
                                )?,
                            );
                        }
                    }
                }
                4u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 4u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    if depth == 0 {
                        return Err(::buffa::DecodeError::RecursionLimitExceeded);
                    }
                    let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                    if let Some(
                        super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::FileDescriptorResponse(
                            ref mut existing,
                        ),
                    ) = view.message_response
                    {
                        existing._merge_into_view(sub, depth - 1)?;
                    } else {
                        view.message_response = Some(
                            super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::FileDescriptorResponse(
                                ::buffa::alloc::boxed::Box::new(
                                    super::super::__buffa::view::FileDescriptorResponseView::_decode_depth(
                                        sub,
                                        depth - 1,
                                    )?,
                                ),
                            ),
                        );
                    }
                }
                5u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 5u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    if depth == 0 {
                        return Err(::buffa::DecodeError::RecursionLimitExceeded);
                    }
                    let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                    if let Some(
                        super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::AllExtensionNumbersResponse(
                            ref mut existing,
                        ),
                    ) = view.message_response
                    {
                        existing._merge_into_view(sub, depth - 1)?;
                    } else {
                        view.message_response = Some(
                            super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::AllExtensionNumbersResponse(
                                ::buffa::alloc::boxed::Box::new(
                                    super::super::__buffa::view::ExtensionNumberResponseView::_decode_depth(
                                        sub,
                                        depth - 1,
                                    )?,
                                ),
                            ),
                        );
                    }
                }
                6u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 6u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    if depth == 0 {
                        return Err(::buffa::DecodeError::RecursionLimitExceeded);
                    }
                    let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                    if let Some(
                        super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::ListServicesResponse(
                            ref mut existing,
                        ),
                    ) = view.message_response
                    {
                        existing._merge_into_view(sub, depth - 1)?;
                    } else {
                        view.message_response = Some(
                            super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::ListServicesResponse(
                                ::buffa::alloc::boxed::Box::new(
                                    super::super::__buffa::view::ListServiceResponseView::_decode_depth(
                                        sub,
                                        depth - 1,
                                    )?,
                                ),
                            ),
                        );
                    }
                }
                7u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 7u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    if depth == 0 {
                        return Err(::buffa::DecodeError::RecursionLimitExceeded);
                    }
                    let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                    if let Some(
                        super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::ErrorResponse(
                            ref mut existing,
                        ),
                    ) = view.message_response
                    {
                        existing._merge_into_view(sub, depth - 1)?;
                    } else {
                        view.message_response = Some(
                            super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::ErrorResponse(
                                ::buffa::alloc::boxed::Box::new(
                                    super::super::__buffa::view::ErrorResponseView::_decode_depth(
                                        sub,
                                        depth - 1,
                                    )?,
                                ),
                            ),
                        );
                    }
                }
                _ => {
                    ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
                    let span_len = before_tag.len() - cur.len();
                    view.__buffa_unknown_fields.push_raw(&before_tag[..span_len]);
                }
            }
        }
        ::core::result::Result::Ok(())
    }
}
impl<'a> ::buffa::MessageView<'a> for ServerReflectionResponseView<'a> {
    type Owned = super::super::ServerReflectionResponse;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
    }
    fn decode_view_with_limit(
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        Self::_decode_depth(buf, depth)
    }
    fn to_owned_message(&self) -> super::super::ServerReflectionResponse {
        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>,
    ) -> super::super::ServerReflectionResponse {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        super::super::ServerReflectionResponse {
            valid_host: self.valid_host.to_string(),
            original_request: match self.original_request.as_option() {
                Some(v) => {
                    ::buffa::MessageField::<
                        super::super::ServerReflectionRequest,
                    >::some(v.to_owned_from_source(__buffa_src))
                }
                None => ::buffa::MessageField::none(),
            },
            message_response: self
                .message_response
                .as_ref()
                .map(|v| match v {
                    super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::FileDescriptorResponse(
                        v,
                    ) => {
                        super::super::__buffa::oneof::server_reflection_response::MessageResponse::FileDescriptorResponse(
                            ::buffa::alloc::boxed::Box::new(
                                v.to_owned_from_source(__buffa_src),
                            ),
                        )
                    }
                    super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::AllExtensionNumbersResponse(
                        v,
                    ) => {
                        super::super::__buffa::oneof::server_reflection_response::MessageResponse::AllExtensionNumbersResponse(
                            ::buffa::alloc::boxed::Box::new(
                                v.to_owned_from_source(__buffa_src),
                            ),
                        )
                    }
                    super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::ListServicesResponse(
                        v,
                    ) => {
                        super::super::__buffa::oneof::server_reflection_response::MessageResponse::ListServicesResponse(
                            ::buffa::alloc::boxed::Box::new(
                                v.to_owned_from_source(__buffa_src),
                            ),
                        )
                    }
                    super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::ErrorResponse(
                        v,
                    ) => {
                        super::super::__buffa::oneof::server_reflection_response::MessageResponse::ErrorResponse(
                            ::buffa::alloc::boxed::Box::new(
                                v.to_owned_from_source(__buffa_src),
                            ),
                        )
                    }
                }),
            __buffa_unknown_fields: self
                .__buffa_unknown_fields
                .to_owned()
                .unwrap_or_default()
                .into(),
            ..::core::default::Default::default()
        }
    }
}
impl<'a> ::buffa::ViewEncode<'a> for ServerReflectionResponseView<'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 = 0u32;
        if !self.valid_host.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.valid_host) as u32;
        }
        if self.original_request.is_set() {
            let __slot = __cache.reserve();
            let inner_size = self.original_request.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        if let ::core::option::Option::Some(ref v) = self.message_response {
            match v {
                super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::FileDescriptorResponse(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
                super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::AllExtensionNumbersResponse(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
                super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::ListServicesResponse(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
                super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::ErrorResponse(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
                            + inner;
                }
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.valid_host.is_empty() {
            ::buffa::encoding::Tag::new(
                    1u32,
                    ::buffa::encoding::WireType::LengthDelimited,
                )
                .encode(buf);
            ::buffa::types::encode_string(&self.valid_host, buf);
        }
        if self.original_request.is_set() {
            ::buffa::encoding::Tag::new(
                    2u32,
                    ::buffa::encoding::WireType::LengthDelimited,
                )
                .encode(buf);
            ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
            self.original_request.write_to(__cache, buf);
        }
        if let ::core::option::Option::Some(ref v) = self.message_response {
            match v {
                super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::FileDescriptorResponse(
                    x,
                ) => {
                    ::buffa::encoding::Tag::new(
                            4u32,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )
                        .encode(buf);
                    ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::AllExtensionNumbersResponse(
                    x,
                ) => {
                    ::buffa::encoding::Tag::new(
                            5u32,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )
                        .encode(buf);
                    ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::ListServicesResponse(
                    x,
                ) => {
                    ::buffa::encoding::Tag::new(
                            6u32,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )
                        .encode(buf);
                    ::buffa::encoding::encode_varint(__cache.consume_next() as u64, buf);
                    x.write_to(__cache, buf);
                }
                super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::ErrorResponse(
                    x,
                ) => {
                    ::buffa::encoding::Tag::new(
                            7u32,
                            ::buffa::encoding::WireType::LengthDelimited,
                        )
                        .encode(buf);
                    ::buffa::encoding::encode_varint(__cache.consume_next() as u64, 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 ServerReflectionResponseView<'__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.valid_host) {
            __map.serialize_entry("validHost", self.valid_host)?;
        }
        {
            if let ::core::option::Option::Some(__v) = self.original_request.as_option()
            {
                __map.serialize_entry("originalRequest", __v)?;
            }
        }
        if let ::core::option::Option::Some(ref __ov) = self.message_response {
            match __ov {
                super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::FileDescriptorResponse(
                    v,
                ) => {
                    __map.serialize_entry("fileDescriptorResponse", v)?;
                }
                super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::AllExtensionNumbersResponse(
                    v,
                ) => {
                    __map.serialize_entry("allExtensionNumbersResponse", v)?;
                }
                super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::ListServicesResponse(
                    v,
                ) => {
                    __map.serialize_entry("listServicesResponse", v)?;
                }
                super::super::__buffa::view::oneof::server_reflection_response::MessageResponse::ErrorResponse(
                    v,
                ) => {
                    __map.serialize_entry("errorResponse", v)?;
                }
            }
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for ServerReflectionResponseView<'a> {
    const PACKAGE: &'static str = "grpc.reflection.v1alpha";
    const NAME: &'static str = "ServerReflectionResponse";
    const FULL_NAME: &'static str = "grpc.reflection.v1alpha.ServerReflectionResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ServerReflectionResponse";
}
impl<'v> ::buffa::DefaultViewInstance for ServerReflectionResponseView<'v> {
    fn default_view_instance<'a>() -> &'a Self
    where
        Self: 'a,
    {
        static VALUE: ::buffa::__private::OnceBox<
            ServerReflectionResponseView<'static>,
        > = ::buffa::__private::OnceBox::new();
        VALUE
            .get_or_init(|| ::buffa::alloc::boxed::Box::new(
                <ServerReflectionResponseView<'static>>::default(),
            ))
    }
}
impl ::buffa::ViewReborrow for ServerReflectionResponseView<'static> {
    type Reborrowed<'b> = ServerReflectionResponseView<'b>;
    fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
        this
    }
}
/** Self-contained, `'static` owned view of a `ServerReflectionResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`ServerReflectionResponseView`]`<'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 [`ServerReflectionResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct ServerReflectionResponseOwnedView(
    ::buffa::OwnedView<ServerReflectionResponseView<'static>>,
);
impl ServerReflectionResponseOwnedView {
    /// 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(
            ServerReflectionResponseOwnedView(::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(
            ServerReflectionResponseOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::ServerReflectionResponse,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            ServerReflectionResponseOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`ServerReflectionResponseView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &ServerReflectionResponseView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::ServerReflectionResponse {
        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_host`
    #[must_use]
    pub fn valid_host(&self) -> &'_ str {
        self.0.reborrow().valid_host
    }
    /// Field 2: `original_request`
    #[must_use]
    pub fn original_request(
        &self,
    ) -> &::buffa::MessageFieldView<
        super::super::__buffa::view::ServerReflectionRequestView<'_>,
    > {
        &self.0.reborrow().original_request
    }
    /// Oneof `message_response`.
    #[must_use]
    pub fn message_response(
        &self,
    ) -> ::core::option::Option<
        &super::super::__buffa::view::oneof::server_reflection_response::MessageResponse<
            '_,
        >,
    > {
        self.0.reborrow().message_response.as_ref()
    }
}
impl ::core::convert::From<::buffa::OwnedView<ServerReflectionResponseView<'static>>>
for ServerReflectionResponseOwnedView {
    fn from(inner: ::buffa::OwnedView<ServerReflectionResponseView<'static>>) -> Self {
        ServerReflectionResponseOwnedView(inner)
    }
}
impl ::core::convert::From<ServerReflectionResponseOwnedView>
for ::buffa::OwnedView<ServerReflectionResponseView<'static>> {
    fn from(wrapper: ServerReflectionResponseOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<ServerReflectionResponseView<'static>>>
for ServerReflectionResponseOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<ServerReflectionResponseView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::ServerReflectionResponse {
    type View<'a> = ServerReflectionResponseView<'a>;
    type ViewHandle = ServerReflectionResponseOwnedView;
}
impl ::serde::Serialize for ServerReflectionResponseOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
/// Serialized FileDescriptorProto messages sent by the server answering
/// a file_by_filename, file_containing_symbol, or file_containing_extension
/// request.
#[derive(Clone, Debug, Default)]
pub struct FileDescriptorResponseView<'a> {
    /// Serialized FileDescriptorProto messages. We avoid taking a dependency on
    /// descriptor.proto, which uses proto2 only features, by making them opaque
    /// bytes instead.
    ///
    /// Field 1: `file_descriptor_proto`
    pub file_descriptor_proto: ::buffa::RepeatedView<'a, &'a [u8]>,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> FileDescriptorResponseView<'a> {
    /// Decode from `buf`, enforcing a recursion depth limit for nested messages.
    ///
    /// Called by [`::buffa::MessageView::decode_view`] with [`::buffa::RECURSION_LIMIT`]
    /// and by generated sub-message decode arms with `depth - 1`.
    ///
    /// **Not part of the public API.** Named with a leading underscore to
    /// signal that it is for generated-code use only.
    #[doc(hidden)]
    pub fn _decode_depth(
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let mut view = Self::default();
        view._merge_into_view(buf, depth)?;
        ::core::result::Result::Ok(view)
    }
    /// Merge fields from `buf` into this view (proto merge semantics).
    ///
    /// Repeated fields append; singular fields last-wins; singular
    /// MESSAGE fields merge recursively. Used by sub-message decode
    /// arms when the same field appears multiple times on the wire.
    ///
    /// **Not part of the public API.**
    #[doc(hidden)]
    pub fn _merge_into_view(
        &mut self,
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        let _ = depth;
        #[allow(unused_variables)]
        let view = self;
        let mut cur: &'a [u8] = buf;
        while !cur.is_empty() {
            let before_tag = cur;
            let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
            match tag.field_number() {
                1u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 1u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    view.file_descriptor_proto
                        .push(::buffa::types::borrow_bytes(&mut cur)?);
                }
                _ => {
                    ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
                    let span_len = before_tag.len() - cur.len();
                    view.__buffa_unknown_fields.push_raw(&before_tag[..span_len]);
                }
            }
        }
        ::core::result::Result::Ok(())
    }
}
impl<'a> ::buffa::MessageView<'a> for FileDescriptorResponseView<'a> {
    type Owned = super::super::FileDescriptorResponse;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
    }
    fn decode_view_with_limit(
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        Self::_decode_depth(buf, depth)
    }
    fn to_owned_message(&self) -> super::super::FileDescriptorResponse {
        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>,
    ) -> super::super::FileDescriptorResponse {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        super::super::FileDescriptorResponse {
            file_descriptor_proto: self
                .file_descriptor_proto
                .iter()
                .map(|b| (b).to_vec())
                .collect(),
            __buffa_unknown_fields: self
                .__buffa_unknown_fields
                .to_owned()
                .unwrap_or_default()
                .into(),
            ..::core::default::Default::default()
        }
    }
}
impl<'a> ::buffa::ViewEncode<'a> for FileDescriptorResponseView<'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 = 0u32;
        for v in &self.file_descriptor_proto {
            size += 1u32 + ::buffa::types::bytes_encoded_len(v) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for v in &self.file_descriptor_proto {
            ::buffa::encoding::Tag::new(
                    1u32,
                    ::buffa::encoding::WireType::LengthDelimited,
                )
                .encode(buf);
            ::buffa::types::encode_bytes(v, 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 FileDescriptorResponseView<'__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.file_descriptor_proto.is_empty() {
            struct _WSeq<'__x>(&'__x [&'__x [u8]]);
            impl ::serde::Serialize for _WSeq<'_> {
                fn serialize<__S: ::serde::Serializer>(
                    &self,
                    __s: __S,
                ) -> ::core::result::Result<__S::Ok, __S::Error> {
                    use ::serde::ser::SerializeSeq as _;
                    let mut __seq = __s
                        .serialize_seq(::core::option::Option::Some(self.0.len()))?;
                    for v in self.0 {
                        struct _WE<'__x>(&'__x [u8]);
                        impl ::serde::Serialize for _WE<'_> {
                            fn serialize<__S: ::serde::Serializer>(
                                &self,
                                __s: __S,
                            ) -> ::core::result::Result<__S::Ok, __S::Error> {
                                ::buffa::json_helpers::bytes::serialize(self.0, __s)
                            }
                        }
                        __seq.serialize_element(&_WE(v))?;
                    }
                    __seq.end()
                }
            }
            __map
                .serialize_entry(
                    "fileDescriptorProto",
                    &_WSeq(&self.file_descriptor_proto),
                )?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for FileDescriptorResponseView<'a> {
    const PACKAGE: &'static str = "grpc.reflection.v1alpha";
    const NAME: &'static str = "FileDescriptorResponse";
    const FULL_NAME: &'static str = "grpc.reflection.v1alpha.FileDescriptorResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.FileDescriptorResponse";
}
impl<'v> ::buffa::DefaultViewInstance for FileDescriptorResponseView<'v> {
    fn default_view_instance<'a>() -> &'a Self
    where
        Self: 'a,
    {
        static VALUE: ::buffa::__private::OnceBox<FileDescriptorResponseView<'static>> = ::buffa::__private::OnceBox::new();
        VALUE
            .get_or_init(|| ::buffa::alloc::boxed::Box::new(
                <FileDescriptorResponseView<'static>>::default(),
            ))
    }
}
impl ::buffa::ViewReborrow for FileDescriptorResponseView<'static> {
    type Reborrowed<'b> = FileDescriptorResponseView<'b>;
    fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
        this
    }
}
/** Self-contained, `'static` owned view of a `FileDescriptorResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`FileDescriptorResponseView`]`<'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 [`FileDescriptorResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct FileDescriptorResponseOwnedView(
    ::buffa::OwnedView<FileDescriptorResponseView<'static>>,
);
impl FileDescriptorResponseOwnedView {
    /// 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(
            FileDescriptorResponseOwnedView(::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(
            FileDescriptorResponseOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::FileDescriptorResponse,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            FileDescriptorResponseOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`FileDescriptorResponseView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &FileDescriptorResponseView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::FileDescriptorResponse {
        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()
    }
    /// Serialized FileDescriptorProto messages. We avoid taking a dependency on
    /// descriptor.proto, which uses proto2 only features, by making them opaque
    /// bytes instead.
    ///
    /// Field 1: `file_descriptor_proto`
    #[must_use]
    pub fn file_descriptor_proto(&self) -> &::buffa::RepeatedView<'_, &'_ [u8]> {
        &self.0.reborrow().file_descriptor_proto
    }
}
impl ::core::convert::From<::buffa::OwnedView<FileDescriptorResponseView<'static>>>
for FileDescriptorResponseOwnedView {
    fn from(inner: ::buffa::OwnedView<FileDescriptorResponseView<'static>>) -> Self {
        FileDescriptorResponseOwnedView(inner)
    }
}
impl ::core::convert::From<FileDescriptorResponseOwnedView>
for ::buffa::OwnedView<FileDescriptorResponseView<'static>> {
    fn from(wrapper: FileDescriptorResponseOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<FileDescriptorResponseView<'static>>>
for FileDescriptorResponseOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<FileDescriptorResponseView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::FileDescriptorResponse {
    type View<'a> = FileDescriptorResponseView<'a>;
    type ViewHandle = FileDescriptorResponseOwnedView;
}
impl ::serde::Serialize for FileDescriptorResponseOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
/// A list of extension numbers sent by the server answering
/// all_extension_numbers_of_type request.
#[derive(Clone, Debug, Default)]
pub struct ExtensionNumberResponseView<'a> {
    /// Full name of the base type, including the package name. The format
    /// is \<package\>.\<type\>
    ///
    /// Field 1: `base_type_name`
    pub base_type_name: &'a str,
    /// Field 2: `extension_number`
    pub extension_number: ::buffa::RepeatedView<'a, i32>,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ExtensionNumberResponseView<'a> {
    /// Decode from `buf`, enforcing a recursion depth limit for nested messages.
    ///
    /// Called by [`::buffa::MessageView::decode_view`] with [`::buffa::RECURSION_LIMIT`]
    /// and by generated sub-message decode arms with `depth - 1`.
    ///
    /// **Not part of the public API.** Named with a leading underscore to
    /// signal that it is for generated-code use only.
    #[doc(hidden)]
    pub fn _decode_depth(
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let mut view = Self::default();
        view._merge_into_view(buf, depth)?;
        ::core::result::Result::Ok(view)
    }
    /// Merge fields from `buf` into this view (proto merge semantics).
    ///
    /// Repeated fields append; singular fields last-wins; singular
    /// MESSAGE fields merge recursively. Used by sub-message decode
    /// arms when the same field appears multiple times on the wire.
    ///
    /// **Not part of the public API.**
    #[doc(hidden)]
    pub fn _merge_into_view(
        &mut self,
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        let _ = depth;
        #[allow(unused_variables)]
        let view = self;
        let mut cur: &'a [u8] = buf;
        while !cur.is_empty() {
            let before_tag = cur;
            let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
            match tag.field_number() {
                1u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 1u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    view.base_type_name = ::buffa::types::borrow_str(&mut cur)?;
                }
                2u32 => {
                    if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
                        let payload = ::buffa::types::borrow_bytes(&mut cur)?;
                        let mut pcur: &[u8] = payload;
                        while !pcur.is_empty() {
                            view.extension_number
                                .push(::buffa::types::decode_int32(&mut pcur)?);
                        }
                    } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
                        view.extension_number
                            .push(::buffa::types::decode_int32(&mut cur)?);
                    } else {
                        return Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 2u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                }
                _ => {
                    ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
                    let span_len = before_tag.len() - cur.len();
                    view.__buffa_unknown_fields.push_raw(&before_tag[..span_len]);
                }
            }
        }
        ::core::result::Result::Ok(())
    }
}
impl<'a> ::buffa::MessageView<'a> for ExtensionNumberResponseView<'a> {
    type Owned = super::super::ExtensionNumberResponse;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
    }
    fn decode_view_with_limit(
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        Self::_decode_depth(buf, depth)
    }
    fn to_owned_message(&self) -> super::super::ExtensionNumberResponse {
        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>,
    ) -> super::super::ExtensionNumberResponse {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        super::super::ExtensionNumberResponse {
            base_type_name: self.base_type_name.to_string(),
            extension_number: self.extension_number.to_vec(),
            __buffa_unknown_fields: self
                .__buffa_unknown_fields
                .to_owned()
                .unwrap_or_default()
                .into(),
            ..::core::default::Default::default()
        }
    }
}
impl<'a> ::buffa::ViewEncode<'a> for ExtensionNumberResponseView<'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 = 0u32;
        if !self.base_type_name.is_empty() {
            size
                += 1u32
                    + ::buffa::types::string_encoded_len(&self.base_type_name) as u32;
        }
        if !self.extension_number.is_empty() {
            let payload: u32 = self
                .extension_number
                .iter()
                .map(|&v| ::buffa::types::int32_encoded_len(v) as u32)
                .sum::<u32>();
            size
                += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32 + payload;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.base_type_name.is_empty() {
            ::buffa::encoding::Tag::new(
                    1u32,
                    ::buffa::encoding::WireType::LengthDelimited,
                )
                .encode(buf);
            ::buffa::types::encode_string(&self.base_type_name, buf);
        }
        if !self.extension_number.is_empty() {
            let payload: u32 = self
                .extension_number
                .iter()
                .map(|&v| ::buffa::types::int32_encoded_len(v) as u32)
                .sum::<u32>();
            ::buffa::encoding::Tag::new(
                    2u32,
                    ::buffa::encoding::WireType::LengthDelimited,
                )
                .encode(buf);
            ::buffa::encoding::encode_varint(payload as u64, buf);
            for &v in &self.extension_number {
                ::buffa::types::encode_int32(v, 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 ExtensionNumberResponseView<'__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.base_type_name) {
            __map.serialize_entry("baseTypeName", self.base_type_name)?;
        }
        if !self.extension_number.is_empty() {
            struct _WSeq<'__x>(&'__x [i32]);
            impl ::serde::Serialize for _WSeq<'_> {
                fn serialize<__S: ::serde::Serializer>(
                    &self,
                    __s: __S,
                ) -> ::core::result::Result<__S::Ok, __S::Error> {
                    ::buffa::json_helpers::proto_seq::serialize(self.0, __s)
                }
            }
            __map.serialize_entry("extensionNumber", &_WSeq(&self.extension_number))?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for ExtensionNumberResponseView<'a> {
    const PACKAGE: &'static str = "grpc.reflection.v1alpha";
    const NAME: &'static str = "ExtensionNumberResponse";
    const FULL_NAME: &'static str = "grpc.reflection.v1alpha.ExtensionNumberResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ExtensionNumberResponse";
}
impl<'v> ::buffa::DefaultViewInstance for ExtensionNumberResponseView<'v> {
    fn default_view_instance<'a>() -> &'a Self
    where
        Self: 'a,
    {
        static VALUE: ::buffa::__private::OnceBox<
            ExtensionNumberResponseView<'static>,
        > = ::buffa::__private::OnceBox::new();
        VALUE
            .get_or_init(|| ::buffa::alloc::boxed::Box::new(
                <ExtensionNumberResponseView<'static>>::default(),
            ))
    }
}
impl ::buffa::ViewReborrow for ExtensionNumberResponseView<'static> {
    type Reborrowed<'b> = ExtensionNumberResponseView<'b>;
    fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
        this
    }
}
/** Self-contained, `'static` owned view of a `ExtensionNumberResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`ExtensionNumberResponseView`]`<'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 [`ExtensionNumberResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct ExtensionNumberResponseOwnedView(
    ::buffa::OwnedView<ExtensionNumberResponseView<'static>>,
);
impl ExtensionNumberResponseOwnedView {
    /// 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(
            ExtensionNumberResponseOwnedView(::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(
            ExtensionNumberResponseOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::ExtensionNumberResponse,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            ExtensionNumberResponseOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`ExtensionNumberResponseView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &ExtensionNumberResponseView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::ExtensionNumberResponse {
        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()
    }
    /// Full name of the base type, including the package name. The format
    /// is \<package\>.\<type\>
    ///
    /// Field 1: `base_type_name`
    #[must_use]
    pub fn base_type_name(&self) -> &'_ str {
        self.0.reborrow().base_type_name
    }
    /// Field 2: `extension_number`
    #[must_use]
    pub fn extension_number(&self) -> &::buffa::RepeatedView<'_, i32> {
        &self.0.reborrow().extension_number
    }
}
impl ::core::convert::From<::buffa::OwnedView<ExtensionNumberResponseView<'static>>>
for ExtensionNumberResponseOwnedView {
    fn from(inner: ::buffa::OwnedView<ExtensionNumberResponseView<'static>>) -> Self {
        ExtensionNumberResponseOwnedView(inner)
    }
}
impl ::core::convert::From<ExtensionNumberResponseOwnedView>
for ::buffa::OwnedView<ExtensionNumberResponseView<'static>> {
    fn from(wrapper: ExtensionNumberResponseOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<ExtensionNumberResponseView<'static>>>
for ExtensionNumberResponseOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<ExtensionNumberResponseView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::ExtensionNumberResponse {
    type View<'a> = ExtensionNumberResponseView<'a>;
    type ViewHandle = ExtensionNumberResponseOwnedView;
}
impl ::serde::Serialize for ExtensionNumberResponseOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
/// A list of ServiceResponse sent by the server answering list_services request.
#[derive(Clone, Debug, Default)]
pub struct ListServiceResponseView<'a> {
    /// The information of each service may be expanded in the future, so we use
    /// ServiceResponse message to encapsulate it.
    ///
    /// Field 1: `service`
    pub service: ::buffa::RepeatedView<
        'a,
        super::super::__buffa::view::ServiceResponseView<'a>,
    >,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ListServiceResponseView<'a> {
    /// Decode from `buf`, enforcing a recursion depth limit for nested messages.
    ///
    /// Called by [`::buffa::MessageView::decode_view`] with [`::buffa::RECURSION_LIMIT`]
    /// and by generated sub-message decode arms with `depth - 1`.
    ///
    /// **Not part of the public API.** Named with a leading underscore to
    /// signal that it is for generated-code use only.
    #[doc(hidden)]
    pub fn _decode_depth(
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let mut view = Self::default();
        view._merge_into_view(buf, depth)?;
        ::core::result::Result::Ok(view)
    }
    /// Merge fields from `buf` into this view (proto merge semantics).
    ///
    /// Repeated fields append; singular fields last-wins; singular
    /// MESSAGE fields merge recursively. Used by sub-message decode
    /// arms when the same field appears multiple times on the wire.
    ///
    /// **Not part of the public API.**
    #[doc(hidden)]
    pub fn _merge_into_view(
        &mut self,
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        let _ = depth;
        #[allow(unused_variables)]
        let view = self;
        let mut cur: &'a [u8] = buf;
        while !cur.is_empty() {
            let before_tag = cur;
            let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
            match tag.field_number() {
                1u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 1u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    if depth == 0 {
                        return Err(::buffa::DecodeError::RecursionLimitExceeded);
                    }
                    let sub = ::buffa::types::borrow_bytes(&mut cur)?;
                    view.service
                        .push(
                            super::super::__buffa::view::ServiceResponseView::_decode_depth(
                                sub,
                                depth - 1,
                            )?,
                        );
                }
                _ => {
                    ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
                    let span_len = before_tag.len() - cur.len();
                    view.__buffa_unknown_fields.push_raw(&before_tag[..span_len]);
                }
            }
        }
        ::core::result::Result::Ok(())
    }
}
impl<'a> ::buffa::MessageView<'a> for ListServiceResponseView<'a> {
    type Owned = super::super::ListServiceResponse;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
    }
    fn decode_view_with_limit(
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        Self::_decode_depth(buf, depth)
    }
    fn to_owned_message(&self) -> super::super::ListServiceResponse {
        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>,
    ) -> super::super::ListServiceResponse {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        super::super::ListServiceResponse {
            service: self
                .service
                .iter()
                .map(|v| v.to_owned_from_source(__buffa_src))
                .collect(),
            __buffa_unknown_fields: self
                .__buffa_unknown_fields
                .to_owned()
                .unwrap_or_default()
                .into(),
            ..::core::default::Default::default()
        }
    }
}
impl<'a> ::buffa::ViewEncode<'a> for ListServiceResponseView<'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 = 0u32;
        for v in &self.service {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
                    + inner_size;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for v in &self.service {
            ::buffa::encoding::Tag::new(
                    1u32,
                    ::buffa::encoding::WireType::LengthDelimited,
                )
                .encode(buf);
            ::buffa::encoding::encode_varint(__cache.consume_next() as u64, 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 ListServiceResponseView<'__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.service.is_empty() {
            __map.serialize_entry("service", &*self.service)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for ListServiceResponseView<'a> {
    const PACKAGE: &'static str = "grpc.reflection.v1alpha";
    const NAME: &'static str = "ListServiceResponse";
    const FULL_NAME: &'static str = "grpc.reflection.v1alpha.ListServiceResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ListServiceResponse";
}
impl<'v> ::buffa::DefaultViewInstance for ListServiceResponseView<'v> {
    fn default_view_instance<'a>() -> &'a Self
    where
        Self: 'a,
    {
        static VALUE: ::buffa::__private::OnceBox<ListServiceResponseView<'static>> = ::buffa::__private::OnceBox::new();
        VALUE
            .get_or_init(|| ::buffa::alloc::boxed::Box::new(
                <ListServiceResponseView<'static>>::default(),
            ))
    }
}
impl ::buffa::ViewReborrow for ListServiceResponseView<'static> {
    type Reborrowed<'b> = ListServiceResponseView<'b>;
    fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
        this
    }
}
/** Self-contained, `'static` owned view of a `ListServiceResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`ListServiceResponseView`]`<'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 [`ListServiceResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct ListServiceResponseOwnedView(
    ::buffa::OwnedView<ListServiceResponseView<'static>>,
);
impl ListServiceResponseOwnedView {
    /// 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(
            ListServiceResponseOwnedView(::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(
            ListServiceResponseOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::ListServiceResponse,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            ListServiceResponseOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`ListServiceResponseView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &ListServiceResponseView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::ListServiceResponse {
        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()
    }
    /// The information of each service may be expanded in the future, so we use
    /// ServiceResponse message to encapsulate it.
    ///
    /// Field 1: `service`
    #[must_use]
    pub fn service(
        &self,
    ) -> &::buffa::RepeatedView<
        '_,
        super::super::__buffa::view::ServiceResponseView<'_>,
    > {
        &self.0.reborrow().service
    }
}
impl ::core::convert::From<::buffa::OwnedView<ListServiceResponseView<'static>>>
for ListServiceResponseOwnedView {
    fn from(inner: ::buffa::OwnedView<ListServiceResponseView<'static>>) -> Self {
        ListServiceResponseOwnedView(inner)
    }
}
impl ::core::convert::From<ListServiceResponseOwnedView>
for ::buffa::OwnedView<ListServiceResponseView<'static>> {
    fn from(wrapper: ListServiceResponseOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<ListServiceResponseView<'static>>>
for ListServiceResponseOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<ListServiceResponseView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::ListServiceResponse {
    type View<'a> = ListServiceResponseView<'a>;
    type ViewHandle = ListServiceResponseOwnedView;
}
impl ::serde::Serialize for ListServiceResponseOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
/// The information of a single service used by ListServiceResponse to answer
/// list_services request.
#[derive(Clone, Debug, Default)]
pub struct ServiceResponseView<'a> {
    /// Full name of a registered service, including its package name. The format
    /// is \<package\>.\<service\>
    ///
    /// Field 1: `name`
    pub name: &'a str,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ServiceResponseView<'a> {
    /// Decode from `buf`, enforcing a recursion depth limit for nested messages.
    ///
    /// Called by [`::buffa::MessageView::decode_view`] with [`::buffa::RECURSION_LIMIT`]
    /// and by generated sub-message decode arms with `depth - 1`.
    ///
    /// **Not part of the public API.** Named with a leading underscore to
    /// signal that it is for generated-code use only.
    #[doc(hidden)]
    pub fn _decode_depth(
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let mut view = Self::default();
        view._merge_into_view(buf, depth)?;
        ::core::result::Result::Ok(view)
    }
    /// Merge fields from `buf` into this view (proto merge semantics).
    ///
    /// Repeated fields append; singular fields last-wins; singular
    /// MESSAGE fields merge recursively. Used by sub-message decode
    /// arms when the same field appears multiple times on the wire.
    ///
    /// **Not part of the public API.**
    #[doc(hidden)]
    pub fn _merge_into_view(
        &mut self,
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        let _ = depth;
        #[allow(unused_variables)]
        let view = self;
        let mut cur: &'a [u8] = buf;
        while !cur.is_empty() {
            let before_tag = cur;
            let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
            match tag.field_number() {
                1u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 1u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    view.name = ::buffa::types::borrow_str(&mut cur)?;
                }
                _ => {
                    ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
                    let span_len = before_tag.len() - cur.len();
                    view.__buffa_unknown_fields.push_raw(&before_tag[..span_len]);
                }
            }
        }
        ::core::result::Result::Ok(())
    }
}
impl<'a> ::buffa::MessageView<'a> for ServiceResponseView<'a> {
    type Owned = super::super::ServiceResponse;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
    }
    fn decode_view_with_limit(
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        Self::_decode_depth(buf, depth)
    }
    fn to_owned_message(&self) -> super::super::ServiceResponse {
        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>,
    ) -> super::super::ServiceResponse {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        super::super::ServiceResponse {
            name: self.name.to_string(),
            __buffa_unknown_fields: self
                .__buffa_unknown_fields
                .to_owned()
                .unwrap_or_default()
                .into(),
            ..::core::default::Default::default()
        }
    }
}
impl<'a> ::buffa::ViewEncode<'a> for ServiceResponseView<'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 = 0u32;
        if !self.name.is_empty() {
            size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.name.is_empty() {
            ::buffa::encoding::Tag::new(
                    1u32,
                    ::buffa::encoding::WireType::LengthDelimited,
                )
                .encode(buf);
            ::buffa::types::encode_string(&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 ServiceResponseView<'__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 ServiceResponseView<'a> {
    const PACKAGE: &'static str = "grpc.reflection.v1alpha";
    const NAME: &'static str = "ServiceResponse";
    const FULL_NAME: &'static str = "grpc.reflection.v1alpha.ServiceResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ServiceResponse";
}
impl<'v> ::buffa::DefaultViewInstance for ServiceResponseView<'v> {
    fn default_view_instance<'a>() -> &'a Self
    where
        Self: 'a,
    {
        static VALUE: ::buffa::__private::OnceBox<ServiceResponseView<'static>> = ::buffa::__private::OnceBox::new();
        VALUE
            .get_or_init(|| ::buffa::alloc::boxed::Box::new(
                <ServiceResponseView<'static>>::default(),
            ))
    }
}
impl ::buffa::ViewReborrow for ServiceResponseView<'static> {
    type Reborrowed<'b> = ServiceResponseView<'b>;
    fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
        this
    }
}
/** Self-contained, `'static` owned view of a `ServiceResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`ServiceResponseView`]`<'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 [`ServiceResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct ServiceResponseOwnedView(::buffa::OwnedView<ServiceResponseView<'static>>);
impl ServiceResponseOwnedView {
    /// 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(
            ServiceResponseOwnedView(::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(
            ServiceResponseOwnedView(
                ::buffa::OwnedView::decode_with_options(bytes, opts)?,
            ),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::ServiceResponse,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            ServiceResponseOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`ServiceResponseView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &ServiceResponseView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::ServiceResponse {
        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()
    }
    /// Full name of a registered service, including its package name. The format
    /// is \<package\>.\<service\>
    ///
    /// Field 1: `name`
    #[must_use]
    pub fn name(&self) -> &'_ str {
        self.0.reborrow().name
    }
}
impl ::core::convert::From<::buffa::OwnedView<ServiceResponseView<'static>>>
for ServiceResponseOwnedView {
    fn from(inner: ::buffa::OwnedView<ServiceResponseView<'static>>) -> Self {
        ServiceResponseOwnedView(inner)
    }
}
impl ::core::convert::From<ServiceResponseOwnedView>
for ::buffa::OwnedView<ServiceResponseView<'static>> {
    fn from(wrapper: ServiceResponseOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<ServiceResponseView<'static>>>
for ServiceResponseOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<ServiceResponseView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::ServiceResponse {
    type View<'a> = ServiceResponseView<'a>;
    type ViewHandle = ServiceResponseOwnedView;
}
impl ::serde::Serialize for ServiceResponseOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}
/// The error code and error message sent by the server when an error occurs.
#[derive(Clone, Debug, Default)]
pub struct ErrorResponseView<'a> {
    /// This field uses the error codes defined in grpc::StatusCode.
    ///
    /// Field 1: `error_code`
    pub error_code: i32,
    /// Field 2: `error_message`
    pub error_message: &'a str,
    pub __buffa_unknown_fields: ::buffa::UnknownFieldsView<'a>,
}
impl<'a> ErrorResponseView<'a> {
    /// Decode from `buf`, enforcing a recursion depth limit for nested messages.
    ///
    /// Called by [`::buffa::MessageView::decode_view`] with [`::buffa::RECURSION_LIMIT`]
    /// and by generated sub-message decode arms with `depth - 1`.
    ///
    /// **Not part of the public API.** Named with a leading underscore to
    /// signal that it is for generated-code use only.
    #[doc(hidden)]
    pub fn _decode_depth(
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        let mut view = Self::default();
        view._merge_into_view(buf, depth)?;
        ::core::result::Result::Ok(view)
    }
    /// Merge fields from `buf` into this view (proto merge semantics).
    ///
    /// Repeated fields append; singular fields last-wins; singular
    /// MESSAGE fields merge recursively. Used by sub-message decode
    /// arms when the same field appears multiple times on the wire.
    ///
    /// **Not part of the public API.**
    #[doc(hidden)]
    pub fn _merge_into_view(
        &mut self,
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        let _ = depth;
        #[allow(unused_variables)]
        let view = self;
        let mut cur: &'a [u8] = buf;
        while !cur.is_empty() {
            let before_tag = cur;
            let tag = ::buffa::encoding::Tag::decode(&mut cur)?;
            match tag.field_number() {
                1u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::Varint {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 1u32,
                            expected: 0u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    view.error_code = ::buffa::types::decode_int32(&mut cur)?;
                }
                2u32 => {
                    if tag.wire_type() != ::buffa::encoding::WireType::LengthDelimited {
                        return ::core::result::Result::Err(::buffa::DecodeError::WireTypeMismatch {
                            field_number: 2u32,
                            expected: 2u8,
                            actual: tag.wire_type() as u8,
                        });
                    }
                    view.error_message = ::buffa::types::borrow_str(&mut cur)?;
                }
                _ => {
                    ::buffa::encoding::skip_field_depth(tag, &mut cur, depth)?;
                    let span_len = before_tag.len() - cur.len();
                    view.__buffa_unknown_fields.push_raw(&before_tag[..span_len]);
                }
            }
        }
        ::core::result::Result::Ok(())
    }
}
impl<'a> ::buffa::MessageView<'a> for ErrorResponseView<'a> {
    type Owned = super::super::ErrorResponse;
    fn decode_view(buf: &'a [u8]) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        Self::_decode_depth(buf, ::buffa::RECURSION_LIMIT)
    }
    fn decode_view_with_limit(
        buf: &'a [u8],
        depth: u32,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        Self::_decode_depth(buf, depth)
    }
    fn to_owned_message(&self) -> super::super::ErrorResponse {
        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>,
    ) -> super::super::ErrorResponse {
        #[allow(unused_imports)]
        use ::buffa::alloc::string::ToString as _;
        let _ = __buffa_src;
        super::super::ErrorResponse {
            error_code: self.error_code,
            error_message: self.error_message.to_string(),
            __buffa_unknown_fields: self
                .__buffa_unknown_fields
                .to_owned()
                .unwrap_or_default()
                .into(),
            ..::core::default::Default::default()
        }
    }
}
impl<'a> ::buffa::ViewEncode<'a> for ErrorResponseView<'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 = 0u32;
        if self.error_code != 0i32 {
            size += 1u32 + ::buffa::types::int32_encoded_len(self.error_code) as u32;
        }
        if !self.error_message.is_empty() {
            size
                += 1u32 + ::buffa::types::string_encoded_len(&self.error_message) as u32;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u32;
        size
    }
    #[allow(clippy::needless_borrow)]
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::bytes::BufMut,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.error_code != 0i32 {
            ::buffa::encoding::Tag::new(1u32, ::buffa::encoding::WireType::Varint)
                .encode(buf);
            ::buffa::types::encode_int32(self.error_code, buf);
        }
        if !self.error_message.is_empty() {
            ::buffa::encoding::Tag::new(
                    2u32,
                    ::buffa::encoding::WireType::LengthDelimited,
                )
                .encode(buf);
            ::buffa::types::encode_string(&self.error_message, 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 ErrorResponseView<'__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_i32(&self.error_code) {
            struct _W(i32);
            impl ::serde::Serialize for _W {
                fn serialize<__S: ::serde::Serializer>(
                    &self,
                    __s: __S,
                ) -> ::core::result::Result<__S::Ok, __S::Error> {
                    ::buffa::json_helpers::int32::serialize(&self.0, __s)
                }
            }
            __map.serialize_entry("errorCode", &_W(self.error_code))?;
        }
        if !::buffa::json_helpers::skip_if::is_empty_str(self.error_message) {
            __map.serialize_entry("errorMessage", self.error_message)?;
        }
        __map.end()
    }
}
impl<'a> ::buffa::MessageName for ErrorResponseView<'a> {
    const PACKAGE: &'static str = "grpc.reflection.v1alpha";
    const NAME: &'static str = "ErrorResponse";
    const FULL_NAME: &'static str = "grpc.reflection.v1alpha.ErrorResponse";
    const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ErrorResponse";
}
impl<'v> ::buffa::DefaultViewInstance for ErrorResponseView<'v> {
    fn default_view_instance<'a>() -> &'a Self
    where
        Self: 'a,
    {
        static VALUE: ::buffa::__private::OnceBox<ErrorResponseView<'static>> = ::buffa::__private::OnceBox::new();
        VALUE
            .get_or_init(|| ::buffa::alloc::boxed::Box::new(
                <ErrorResponseView<'static>>::default(),
            ))
    }
}
impl ::buffa::ViewReborrow for ErrorResponseView<'static> {
    type Reborrowed<'b> = ErrorResponseView<'b>;
    fn reborrow<'b>(this: &'b Self) -> &'b Self::Reborrowed<'b> {
        this
    }
}
/** Self-contained, `'static` owned view of a `ErrorResponse` message.

 Wraps [`::buffa::OwnedView`]`<`[`ErrorResponseView`]`<'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 [`ErrorResponseView`] when you need struct patterns, iteration helpers, or to pass the view to lifetime-parameterised code.*/
#[derive(Clone, Debug)]
pub struct ErrorResponseOwnedView(::buffa::OwnedView<ErrorResponseView<'static>>);
impl ErrorResponseOwnedView {
    /// 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(
            ErrorResponseOwnedView(::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(
            ErrorResponseOwnedView(::buffa::OwnedView::decode_with_options(bytes, opts)?),
        )
    }
    /// Build from an owned message via an encode → decode round-trip.
    ///
    /// # Errors
    ///
    /// Returns [`::buffa::DecodeError`] if the re-encoded bytes are
    /// somehow invalid (should not happen for well-formed messages).
    pub fn from_owned(
        msg: &super::super::ErrorResponse,
    ) -> ::core::result::Result<Self, ::buffa::DecodeError> {
        ::core::result::Result::Ok(
            ErrorResponseOwnedView(::buffa::OwnedView::from_owned(msg)?),
        )
    }
    /// Borrow the full [`ErrorResponseView`] with its lifetime tied to `&self`.
    #[must_use]
    pub fn view(&self) -> &ErrorResponseView<'_> {
        self.0.reborrow()
    }
    /// Convert to the owned message type.
    #[must_use]
    pub fn to_owned_message(&self) -> super::super::ErrorResponse {
        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()
    }
    /// This field uses the error codes defined in grpc::StatusCode.
    ///
    /// Field 1: `error_code`
    #[must_use]
    pub fn error_code(&self) -> i32 {
        self.0.reborrow().error_code
    }
    /// Field 2: `error_message`
    #[must_use]
    pub fn error_message(&self) -> &'_ str {
        self.0.reborrow().error_message
    }
}
impl ::core::convert::From<::buffa::OwnedView<ErrorResponseView<'static>>>
for ErrorResponseOwnedView {
    fn from(inner: ::buffa::OwnedView<ErrorResponseView<'static>>) -> Self {
        ErrorResponseOwnedView(inner)
    }
}
impl ::core::convert::From<ErrorResponseOwnedView>
for ::buffa::OwnedView<ErrorResponseView<'static>> {
    fn from(wrapper: ErrorResponseOwnedView) -> Self {
        wrapper.0
    }
}
impl ::core::convert::AsRef<::buffa::OwnedView<ErrorResponseView<'static>>>
for ErrorResponseOwnedView {
    fn as_ref(&self) -> &::buffa::OwnedView<ErrorResponseView<'static>> {
        &self.0
    }
}
impl ::buffa::HasMessageView for super::super::ErrorResponse {
    type View<'a> = ErrorResponseView<'a>;
    type ViewHandle = ErrorResponseOwnedView;
}
impl ::serde::Serialize for ErrorResponseOwnedView {
    fn serialize<__S: ::serde::Serializer>(
        &self,
        __s: __S,
    ) -> ::core::result::Result<__S::Ok, __S::Error> {
        ::serde::Serialize::serialize(&self.0, __s)
    }
}