connectrpc_reflection/generated/buffa/

grpc.reflection.v1alpha.reflection.rs

// @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, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default)]
pub struct ServerReflectionRequest {
    /// Field 1: `host`
    #[serde(
        rename = "host",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub host: ::buffa::alloc::string::String,
    #[serde(flatten)]
    pub message_request: ::core::option::Option<
        __buffa::oneof::server_reflection_request::MessageRequest,
    >,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for ServerReflectionRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ServerReflectionRequest")
            .field("host", &self.host)
            .field("message_request", &self.message_request)
            .finish()
    }
}
impl ServerReflectionRequest {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ServerReflectionRequest";
}
::buffa::impl_default_instance!(ServerReflectionRequest);
impl ::buffa::MessageName for ServerReflectionRequest {
    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 ::buffa::Message for ServerReflectionRequest {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.host.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.host) as u64;
        }
        if let ::core::option::Option::Some(ref v) = self.message_request {
            match v {
                __buffa::oneof::server_reflection_request::MessageRequest::FileByFilename(
                    x,
                ) => {
                    size += 1u64 + ::buffa::types::string_encoded_len(x) as u64;
                }
                __buffa::oneof::server_reflection_request::MessageRequest::FileContainingSymbol(
                    x,
                ) => {
                    size += 1u64 + ::buffa::types::string_encoded_len(x) as u64;
                }
                __buffa::oneof::server_reflection_request::MessageRequest::FileContainingExtension(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::server_reflection_request::MessageRequest::AllExtensionNumbersOfType(
                    x,
                ) => {
                    size += 1u64 + ::buffa::types::string_encoded_len(x) as u64;
                }
                __buffa::oneof::server_reflection_request::MessageRequest::ListServices(
                    x,
                ) => {
                    size += 1u64 + ::buffa::types::string_encoded_len(x) as u64;
                }
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.host.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.host, buf);
        }
        if let ::core::option::Option::Some(ref v) = self.message_request {
            match v {
                __buffa::oneof::server_reflection_request::MessageRequest::FileByFilename(
                    x,
                ) => {
                    ::buffa::types::put_string_field(3u32, x, buf);
                }
                __buffa::oneof::server_reflection_request::MessageRequest::FileContainingSymbol(
                    x,
                ) => {
                    ::buffa::types::put_string_field(4u32, x, buf);
                }
                __buffa::oneof::server_reflection_request::MessageRequest::FileContainingExtension(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        5u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::server_reflection_request::MessageRequest::AllExtensionNumbersOfType(
                    x,
                ) => {
                    ::buffa::types::put_string_field(6u32, x, buf);
                }
                __buffa::oneof::server_reflection_request::MessageRequest::ListServices(
                    x,
                ) => {
                    ::buffa::types::put_string_field(7u32, x, buf);
                }
            }
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.host, buf)?;
            }
            3u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                self.message_request = ::core::option::Option::Some(
                    __buffa::oneof::server_reflection_request::MessageRequest::FileByFilename(
                        ::buffa::types::decode_string(buf)?,
                    ),
                );
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                self.message_request = ::core::option::Option::Some(
                    __buffa::oneof::server_reflection_request::MessageRequest::FileContainingSymbol(
                        ::buffa::types::decode_string(buf)?,
                    ),
                );
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::server_reflection_request::MessageRequest::FileContainingExtension(
                        ref mut existing,
                    ),
                ) = self.message_request
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.message_request = ::core::option::Option::Some(
                        __buffa::oneof::server_reflection_request::MessageRequest::FileContainingExtension(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                self.message_request = ::core::option::Option::Some(
                    __buffa::oneof::server_reflection_request::MessageRequest::AllExtensionNumbersOfType(
                        ::buffa::types::decode_string(buf)?,
                    ),
                );
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                self.message_request = ::core::option::Option::Some(
                    __buffa::oneof::server_reflection_request::MessageRequest::ListServices(
                        ::buffa::types::decode_string(buf)?,
                    ),
                );
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.host.clear();
        self.message_request = ::core::option::Option::None;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ServerReflectionRequest {
    const PROTO_FQN: &'static str = "grpc.reflection.v1alpha.ServerReflectionRequest";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl<'de> serde::Deserialize<'de> for ServerReflectionRequest {
    fn deserialize<D: serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl<'de> serde::de::Visitor<'de> for _V {
            type Value = ServerReflectionRequest;
            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                f.write_str("struct ServerReflectionRequest")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<ServerReflectionRequest, A::Error> {
                let mut __f_host: ::core::option::Option<
                    ::buffa::alloc::string::String,
                > = None;
                let mut __oneof_message_request: ::core::option::Option<
                    __buffa::oneof::server_reflection_request::MessageRequest,
                > = None;
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "host" => {
                            __f_host = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::buffa::alloc::string::String;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::buffa::alloc::string::String,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::proto_string::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "fileByFilename" | "file_by_filename" => {
                            let v: ::core::option::Option<
                                ::buffa::alloc::string::String,
                            > = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            ::buffa::alloc::string::String,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_message_request.is_some() {
                                    return Err(
                                        serde::de::Error::custom(
                                            "multiple oneof fields set for 'message_request'",
                                        ),
                                    );
                                }
                                __oneof_message_request = Some(
                                    __buffa::oneof::server_reflection_request::MessageRequest::FileByFilename(
                                        v,
                                    ),
                                );
                            }
                        }
                        "fileContainingSymbol" | "file_containing_symbol" => {
                            let v: ::core::option::Option<
                                ::buffa::alloc::string::String,
                            > = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            ::buffa::alloc::string::String,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_message_request.is_some() {
                                    return Err(
                                        serde::de::Error::custom(
                                            "multiple oneof fields set for 'message_request'",
                                        ),
                                    );
                                }
                                __oneof_message_request = Some(
                                    __buffa::oneof::server_reflection_request::MessageRequest::FileContainingSymbol(
                                        v,
                                    ),
                                );
                            }
                        }
                        "fileContainingExtension" | "file_containing_extension" => {
                            let v: ::core::option::Option<ExtensionRequest> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            ExtensionRequest,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_message_request.is_some() {
                                    return Err(
                                        serde::de::Error::custom(
                                            "multiple oneof fields set for 'message_request'",
                                        ),
                                    );
                                }
                                __oneof_message_request = Some(
                                    __buffa::oneof::server_reflection_request::MessageRequest::FileContainingExtension(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "allExtensionNumbersOfType"
                        | "all_extension_numbers_of_type" => {
                            let v: ::core::option::Option<
                                ::buffa::alloc::string::String,
                            > = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            ::buffa::alloc::string::String,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_message_request.is_some() {
                                    return Err(
                                        serde::de::Error::custom(
                                            "multiple oneof fields set for 'message_request'",
                                        ),
                                    );
                                }
                                __oneof_message_request = Some(
                                    __buffa::oneof::server_reflection_request::MessageRequest::AllExtensionNumbersOfType(
                                        v,
                                    ),
                                );
                            }
                        }
                        "listServices" | "list_services" => {
                            let v: ::core::option::Option<
                                ::buffa::alloc::string::String,
                            > = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            ::buffa::alloc::string::String,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_message_request.is_some() {
                                    return Err(
                                        serde::de::Error::custom(
                                            "multiple oneof fields set for 'message_request'",
                                        ),
                                    );
                                }
                                __oneof_message_request = Some(
                                    __buffa::oneof::server_reflection_request::MessageRequest::ListServices(
                                        v,
                                    ),
                                );
                            }
                        }
                        _ => {
                            map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                let mut __r = <ServerReflectionRequest as ::core::default::Default>::default();
                if let ::core::option::Option::Some(v) = __f_host {
                    __r.host = v;
                }
                __r.message_request = __oneof_message_request;
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for ServerReflectionRequest {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __SERVER_REFLECTION_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/grpc.reflection.v1alpha.ServerReflectionRequest",
    to_json: ::buffa::type_registry::any_to_json::<ServerReflectionRequest>,
    from_json: ::buffa::type_registry::any_from_json::<ServerReflectionRequest>,
    is_wkt: false,
};
pub mod server_reflection_request {
    #[allow(unused_imports)]
    use super::*;
    #[doc(inline)]
    pub use super::__buffa::oneof::server_reflection_request::MessageRequest;
    #[doc(inline)]
    pub use super::__buffa::view::oneof::server_reflection_request::MessageRequest as MessageRequestView;
}
/// The type name and extension number sent by the client when requesting
/// file_containing_extension.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct ExtensionRequest {
    /// Fully-qualified type name. The format should be \<package\>.\<type\>
    ///
    /// Field 1: `containing_type`
    #[serde(
        rename = "containingType",
        alias = "containing_type",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub containing_type: ::buffa::alloc::string::String,
    /// Field 2: `extension_number`
    #[serde(
        rename = "extensionNumber",
        alias = "extension_number",
        with = "::buffa::json_helpers::int32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i32"
    )]
    pub extension_number: i32,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for ExtensionRequest {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ExtensionRequest")
            .field("containing_type", &self.containing_type)
            .field("extension_number", &self.extension_number)
            .finish()
    }
}
impl ExtensionRequest {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ExtensionRequest";
}
::buffa::impl_default_instance!(ExtensionRequest);
impl ::buffa::MessageName for ExtensionRequest {
    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 ::buffa::Message for ExtensionRequest {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.containing_type.is_empty() {
            size
                += 1u64
                    + ::buffa::types::string_encoded_len(&self.containing_type) as u64;
        }
        if self.extension_number != 0i32 {
            size
                += 1u64
                    + ::buffa::types::int32_encoded_len(self.extension_number) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.containing_type.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.containing_type, buf);
        }
        if self.extension_number != 0i32 {
            ::buffa::types::put_int32_field(2u32, self.extension_number, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.containing_type, buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.extension_number = ::buffa::types::decode_int32(buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.containing_type.clear();
        self.extension_number = 0i32;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ExtensionRequest {
    const PROTO_FQN: &'static str = "grpc.reflection.v1alpha.ExtensionRequest";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for ExtensionRequest {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __EXTENSION_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/grpc.reflection.v1alpha.ExtensionRequest",
    to_json: ::buffa::type_registry::any_to_json::<ExtensionRequest>,
    from_json: ::buffa::type_registry::any_from_json::<ExtensionRequest>,
    is_wkt: false,
};
/// The message sent by the server to answer ServerReflectionInfo method.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize)]
#[serde(default)]
pub struct ServerReflectionResponse {
    /// Field 1: `valid_host`
    #[serde(
        rename = "validHost",
        alias = "valid_host",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub valid_host: ::buffa::alloc::string::String,
    /// Field 2: `original_request`
    #[serde(
        rename = "originalRequest",
        alias = "original_request",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
    )]
    pub original_request: ::buffa::MessageField<
        ServerReflectionRequest,
        ::buffa::Inline<ServerReflectionRequest>,
    >,
    #[serde(flatten)]
    pub message_response: ::core::option::Option<
        __buffa::oneof::server_reflection_response::MessageResponse,
    >,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for ServerReflectionResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ServerReflectionResponse")
            .field("valid_host", &self.valid_host)
            .field("original_request", &self.original_request)
            .field("message_response", &self.message_response)
            .finish()
    }
}
impl ServerReflectionResponse {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ServerReflectionResponse";
}
::buffa::impl_default_instance!(ServerReflectionResponse);
impl ::buffa::MessageName for ServerReflectionResponse {
    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 ::buffa::Message for ServerReflectionResponse {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.valid_host.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.valid_host) as u64;
        }
        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
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        if let ::core::option::Option::Some(ref v) = self.message_response {
            match v {
                __buffa::oneof::server_reflection_response::MessageResponse::FileDescriptorResponse(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::server_reflection_response::MessageResponse::AllExtensionNumbersResponse(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::server_reflection_response::MessageResponse::ListServicesResponse(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
                __buffa::oneof::server_reflection_response::MessageResponse::ErrorResponse(
                    x,
                ) => {
                    let __slot = __cache.reserve();
                    let inner = x.compute_size(__cache);
                    __cache.set(__slot, inner);
                    size
                        += 1u64 + ::buffa::encoding::varint_len(inner as u64) as u64
                            + inner as u64;
                }
            }
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.valid_host.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.valid_host, buf);
        }
        if self.original_request.is_set() {
            ::buffa::types::put_len_delimited_header(
                2u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            self.original_request.write_to(__cache, buf);
        }
        if let ::core::option::Option::Some(ref v) = self.message_response {
            match v {
                __buffa::oneof::server_reflection_response::MessageResponse::FileDescriptorResponse(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        4u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::server_reflection_response::MessageResponse::AllExtensionNumbersResponse(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        5u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::server_reflection_response::MessageResponse::ListServicesResponse(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        6u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
                __buffa::oneof::server_reflection_response::MessageResponse::ErrorResponse(
                    x,
                ) => {
                    ::buffa::types::put_len_delimited_header(
                        7u32,
                        u64::from(__cache.consume_next()),
                        buf,
                    );
                    x.write_to(__cache, buf);
                }
            }
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.valid_host, buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::Message::merge_length_delimited(
                    self.original_request.get_or_insert_default(),
                    buf,
                    ctx,
                )?;
            }
            4u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::server_reflection_response::MessageResponse::FileDescriptorResponse(
                        ref mut existing,
                    ),
                ) = self.message_response
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.message_response = ::core::option::Option::Some(
                        __buffa::oneof::server_reflection_response::MessageResponse::FileDescriptorResponse(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            5u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::server_reflection_response::MessageResponse::AllExtensionNumbersResponse(
                        ref mut existing,
                    ),
                ) = self.message_response
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.message_response = ::core::option::Option::Some(
                        __buffa::oneof::server_reflection_response::MessageResponse::AllExtensionNumbersResponse(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            6u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::server_reflection_response::MessageResponse::ListServicesResponse(
                        ref mut existing,
                    ),
                ) = self.message_response
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.message_response = ::core::option::Option::Some(
                        __buffa::oneof::server_reflection_response::MessageResponse::ListServicesResponse(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            7u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                if let ::core::option::Option::Some(
                    __buffa::oneof::server_reflection_response::MessageResponse::ErrorResponse(
                        ref mut existing,
                    ),
                ) = self.message_response
                {
                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
                } else {
                    let mut val = ::core::default::Default::default();
                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
                    self.message_response = ::core::option::Option::Some(
                        __buffa::oneof::server_reflection_response::MessageResponse::ErrorResponse(
                            ::buffa::alloc::boxed::Box::new(val),
                        ),
                    );
                }
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.valid_host.clear();
        self.original_request = ::buffa::MessageField::none();
        self.message_response = ::core::option::Option::None;
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ServerReflectionResponse {
    const PROTO_FQN: &'static str = "grpc.reflection.v1alpha.ServerReflectionResponse";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl<'de> serde::Deserialize<'de> for ServerReflectionResponse {
    fn deserialize<D: serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        struct _V;
        impl<'de> serde::de::Visitor<'de> for _V {
            type Value = ServerReflectionResponse;
            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                f.write_str("struct ServerReflectionResponse")
            }
            #[allow(clippy::field_reassign_with_default)]
            fn visit_map<A: serde::de::MapAccess<'de>>(
                self,
                mut map: A,
            ) -> ::core::result::Result<ServerReflectionResponse, A::Error> {
                let mut __f_valid_host: ::core::option::Option<
                    ::buffa::alloc::string::String,
                > = None;
                let mut __f_original_request: ::core::option::Option<
                    ::buffa::MessageField<
                        ServerReflectionRequest,
                        ::buffa::Inline<ServerReflectionRequest>,
                    >,
                > = None;
                let mut __oneof_message_response: ::core::option::Option<
                    __buffa::oneof::server_reflection_response::MessageResponse,
                > = None;
                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
                    match key.as_str() {
                        "validHost" | "valid_host" => {
                            __f_valid_host = Some({
                                struct _S;
                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
                                    type Value = ::buffa::alloc::string::String;
                                    fn deserialize<D: serde::Deserializer<'de>>(
                                        self,
                                        d: D,
                                    ) -> ::core::result::Result<
                                        ::buffa::alloc::string::String,
                                        D::Error,
                                    > {
                                        ::buffa::json_helpers::proto_string::deserialize(d)
                                    }
                                }
                                map.next_value_seed(_S)?
                            });
                        }
                        "originalRequest" | "original_request" => {
                            __f_original_request = Some(
                                map
                                    .next_value::<
                                        ::buffa::MessageField<
                                            ServerReflectionRequest,
                                            ::buffa::Inline<ServerReflectionRequest>,
                                        >,
                                    >()?,
                            );
                        }
                        "fileDescriptorResponse" | "file_descriptor_response" => {
                            let v: ::core::option::Option<FileDescriptorResponse> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            FileDescriptorResponse,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_message_response.is_some() {
                                    return Err(
                                        serde::de::Error::custom(
                                            "multiple oneof fields set for 'message_response'",
                                        ),
                                    );
                                }
                                __oneof_message_response = Some(
                                    __buffa::oneof::server_reflection_response::MessageResponse::FileDescriptorResponse(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "allExtensionNumbersResponse"
                        | "all_extension_numbers_response" => {
                            let v: ::core::option::Option<ExtensionNumberResponse> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            ExtensionNumberResponse,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_message_response.is_some() {
                                    return Err(
                                        serde::de::Error::custom(
                                            "multiple oneof fields set for 'message_response'",
                                        ),
                                    );
                                }
                                __oneof_message_response = Some(
                                    __buffa::oneof::server_reflection_response::MessageResponse::AllExtensionNumbersResponse(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "listServicesResponse" | "list_services_response" => {
                            let v: ::core::option::Option<ListServiceResponse> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            ListServiceResponse,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_message_response.is_some() {
                                    return Err(
                                        serde::de::Error::custom(
                                            "multiple oneof fields set for 'message_response'",
                                        ),
                                    );
                                }
                                __oneof_message_response = Some(
                                    __buffa::oneof::server_reflection_response::MessageResponse::ListServicesResponse(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        "errorResponse" | "error_response" => {
                            let v: ::core::option::Option<ErrorResponse> = map
                                .next_value_seed(
                                    ::buffa::json_helpers::NullableDeserializeSeed(
                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
                                            ErrorResponse,
                                        >::new(),
                                    ),
                                )?;
                            if let Some(v) = v {
                                if __oneof_message_response.is_some() {
                                    return Err(
                                        serde::de::Error::custom(
                                            "multiple oneof fields set for 'message_response'",
                                        ),
                                    );
                                }
                                __oneof_message_response = Some(
                                    __buffa::oneof::server_reflection_response::MessageResponse::ErrorResponse(
                                        ::buffa::alloc::boxed::Box::new(v),
                                    ),
                                );
                            }
                        }
                        _ => {
                            map.next_value::<serde::de::IgnoredAny>()?;
                        }
                    }
                }
                let mut __r = <ServerReflectionResponse as ::core::default::Default>::default();
                if let ::core::option::Option::Some(v) = __f_valid_host {
                    __r.valid_host = v;
                }
                if let ::core::option::Option::Some(v) = __f_original_request {
                    __r.original_request = v;
                }
                __r.message_response = __oneof_message_response;
                Ok(__r)
            }
        }
        d.deserialize_map(_V)
    }
}
impl ::buffa::json_helpers::ProtoElemJson for ServerReflectionResponse {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __SERVER_REFLECTION_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/grpc.reflection.v1alpha.ServerReflectionResponse",
    to_json: ::buffa::type_registry::any_to_json::<ServerReflectionResponse>,
    from_json: ::buffa::type_registry::any_from_json::<ServerReflectionResponse>,
    is_wkt: false,
};
pub mod server_reflection_response {
    #[allow(unused_imports)]
    use super::*;
    #[doc(inline)]
    pub use super::__buffa::oneof::server_reflection_response::MessageResponse;
    #[doc(inline)]
    pub use super::__buffa::view::oneof::server_reflection_response::MessageResponse as MessageResponseView;
}
/// Serialized FileDescriptorProto messages sent by the server answering
/// a file_by_filename, file_containing_symbol, or file_containing_extension
/// request.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct FileDescriptorResponse {
    /// 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`
    #[serde(
        rename = "fileDescriptorProto",
        alias = "file_descriptor_proto",
        with = "::buffa::json_helpers::proto_seq",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
    )]
    pub file_descriptor_proto: ::buffa::alloc::vec::Vec<::buffa::alloc::vec::Vec<u8>>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for FileDescriptorResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("FileDescriptorResponse")
            .field("file_descriptor_proto", &self.file_descriptor_proto)
            .finish()
    }
}
impl FileDescriptorResponse {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.FileDescriptorResponse";
}
::buffa::impl_default_instance!(FileDescriptorResponse);
impl ::buffa::MessageName for FileDescriptorResponse {
    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 ::buffa::Message for FileDescriptorResponse {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        for v in &self.file_descriptor_proto {
            size += 1u64 + ::buffa::types::bytes_encoded_len(v) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for v in &self.file_descriptor_proto {
            ::buffa::types::put_shared_bytes_field(1u32, v, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let __elem = ::buffa::types::decode_bytes(buf)?;
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&__elem),
                )?;
                self.file_descriptor_proto.push(__elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.file_descriptor_proto.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for FileDescriptorResponse {
    const PROTO_FQN: &'static str = "grpc.reflection.v1alpha.FileDescriptorResponse";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for FileDescriptorResponse {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __FILE_DESCRIPTOR_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/grpc.reflection.v1alpha.FileDescriptorResponse",
    to_json: ::buffa::type_registry::any_to_json::<FileDescriptorResponse>,
    from_json: ::buffa::type_registry::any_from_json::<FileDescriptorResponse>,
    is_wkt: false,
};
/// A list of extension numbers sent by the server answering
/// all_extension_numbers_of_type request.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct ExtensionNumberResponse {
    /// Full name of the base type, including the package name. The format
    /// is \<package\>.\<type\>
    ///
    /// Field 1: `base_type_name`
    #[serde(
        rename = "baseTypeName",
        alias = "base_type_name",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub base_type_name: ::buffa::alloc::string::String,
    /// Field 2: `extension_number`
    #[serde(
        rename = "extensionNumber",
        alias = "extension_number",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub extension_number: ::buffa::alloc::vec::Vec<i32>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for ExtensionNumberResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ExtensionNumberResponse")
            .field("base_type_name", &self.base_type_name)
            .field("extension_number", &self.extension_number)
            .finish()
    }
}
impl ExtensionNumberResponse {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ExtensionNumberResponse";
}
::buffa::impl_default_instance!(ExtensionNumberResponse);
impl ::buffa::MessageName for ExtensionNumberResponse {
    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 ::buffa::Message for ExtensionNumberResponse {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.base_type_name.is_empty() {
            size
                += 1u64
                    + ::buffa::types::string_encoded_len(&self.base_type_name) as u64;
        }
        if !self.extension_number.is_empty() {
            let payload: u64 = self
                .extension_number
                .iter()
                .map(|&v| ::buffa::types::int32_encoded_len(v) as u64)
                .sum::<u64>();
            size += 1u64 + ::buffa::encoding::varint_len(payload) as u64 + payload;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.base_type_name.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.base_type_name, buf);
        }
        if !self.extension_number.is_empty() {
            let payload: u64 = self
                .extension_number
                .iter()
                .map(|&v| ::buffa::types::int32_encoded_len(v) as u64)
                .sum::<u64>();
            ::buffa::types::put_len_delimited_header(2u32, payload, buf);
            for &v in &self.extension_number {
                ::buffa::types::encode_int32(v, buf);
            }
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.base_type_name, buf)?;
            }
            2u32 => {
                if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
                    let len = ::buffa::encoding::decode_varint(buf)?;
                    let len = usize::try_from(len)
                        .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
                    if buf.remaining() < len {
                        return ::core::result::Result::Err(
                            ::buffa::DecodeError::UnexpectedEof,
                        );
                    }
                    if buf.chunk().len() >= len {
                        ::buffa::types::extend_packed_int32(
                            &buf.chunk()[..len],
                            &mut self.extension_number,
                            len,
                        )?;
                        buf.advance(len);
                    } else {
                        self.extension_number.reserve(len);
                        let mut limited = buf.take(len);
                        while limited.has_remaining() {
                            self.extension_number
                                .push(::buffa::types::decode_int32_packed(&mut limited)?);
                        }
                        let leftover = limited.remaining();
                        if leftover > 0 {
                            limited.advance(leftover);
                        }
                    }
                } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
                    self.extension_number.push(::buffa::types::decode_int32(buf)?);
                } else {
                    return ::core::result::Result::Err(
                        ::buffa::encoding::wire_type_mismatch(
                            tag,
                            ::buffa::encoding::WireType::LengthDelimited,
                        ),
                    );
                }
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.base_type_name.clear();
        self.extension_number.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ExtensionNumberResponse {
    const PROTO_FQN: &'static str = "grpc.reflection.v1alpha.ExtensionNumberResponse";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for ExtensionNumberResponse {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __EXTENSION_NUMBER_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/grpc.reflection.v1alpha.ExtensionNumberResponse",
    to_json: ::buffa::type_registry::any_to_json::<ExtensionNumberResponse>,
    from_json: ::buffa::type_registry::any_from_json::<ExtensionNumberResponse>,
    is_wkt: false,
};
/// A list of ServiceResponse sent by the server answering list_services request.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct ListServiceResponse {
    /// The information of each service may be expanded in the future, so we use
    /// ServiceResponse message to encapsulate it.
    ///
    /// Field 1: `service`
    #[serde(
        rename = "service",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
        deserialize_with = "::buffa::json_helpers::null_as_default"
    )]
    pub service: ::buffa::alloc::vec::Vec<ServiceResponse>,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for ListServiceResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ListServiceResponse").field("service", &self.service).finish()
    }
}
impl ListServiceResponse {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ListServiceResponse";
}
::buffa::impl_default_instance!(ListServiceResponse);
impl ::buffa::MessageName for ListServiceResponse {
    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 ::buffa::Message for ListServiceResponse {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        for v in &self.service {
            let __slot = __cache.reserve();
            let inner_size = v.compute_size(__cache);
            __cache.set(__slot, inner_size);
            size
                += 1u64 + ::buffa::encoding::varint_len(inner_size as u64) as u64
                    + inner_size as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        __cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        for v in &self.service {
            ::buffa::types::put_len_delimited_header(
                1u32,
                u64::from(__cache.consume_next()),
                buf,
            );
            v.write_to(__cache, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                let mut elem = ::core::default::Default::default();
                ctx.register_element_memory(
                    ::buffa::__private::element_footprint(&elem),
                )?;
                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
                self.service.push(elem);
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.service.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ListServiceResponse {
    const PROTO_FQN: &'static str = "grpc.reflection.v1alpha.ListServiceResponse";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for ListServiceResponse {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __LIST_SERVICE_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/grpc.reflection.v1alpha.ListServiceResponse",
    to_json: ::buffa::type_registry::any_to_json::<ListServiceResponse>,
    from_json: ::buffa::type_registry::any_from_json::<ListServiceResponse>,
    is_wkt: false,
};
/// The information of a single service used by ListServiceResponse to answer
/// list_services request.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct ServiceResponse {
    /// Full name of a registered service, including its package name. The format
    /// is \<package\>.\<service\>
    ///
    /// Field 1: `name`
    #[serde(
        rename = "name",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub name: ::buffa::alloc::string::String,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for ServiceResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ServiceResponse").field("name", &self.name).finish()
    }
}
impl ServiceResponse {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ServiceResponse";
}
::buffa::impl_default_instance!(ServiceResponse);
impl ::buffa::MessageName for ServiceResponse {
    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 ::buffa::Message for ServiceResponse {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if !self.name.is_empty() {
            size += 1u64 + ::buffa::types::string_encoded_len(&self.name) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if !self.name.is_empty() {
            ::buffa::types::put_string_field(1u32, &self.name, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.name, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.name.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ServiceResponse {
    const PROTO_FQN: &'static str = "grpc.reflection.v1alpha.ServiceResponse";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for ServiceResponse {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __SERVICE_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/grpc.reflection.v1alpha.ServiceResponse",
    to_json: ::buffa::type_registry::any_to_json::<ServiceResponse>,
    from_json: ::buffa::type_registry::any_from_json::<ServiceResponse>,
    is_wkt: false,
};
/// The error code and error message sent by the server when an error occurs.
#[derive(Clone, PartialEq, Default)]
#[derive(::serde::Serialize, ::serde::Deserialize)]
#[serde(default)]
pub struct ErrorResponse {
    /// This field uses the error codes defined in grpc::StatusCode.
    ///
    /// Field 1: `error_code`
    #[serde(
        rename = "errorCode",
        alias = "error_code",
        with = "::buffa::json_helpers::int32",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i32"
    )]
    pub error_code: i32,
    /// Field 2: `error_message`
    #[serde(
        rename = "errorMessage",
        alias = "error_message",
        with = "::buffa::json_helpers::proto_string",
        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
    )]
    pub error_message: ::buffa::alloc::string::String,
    #[serde(skip)]
    #[doc(hidden)]
    pub __buffa_unknown_fields: ::buffa::UnknownFields,
}
impl ::core::fmt::Debug for ErrorResponse {
    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        f.debug_struct("ErrorResponse")
            .field("error_code", &self.error_code)
            .field("error_message", &self.error_message)
            .finish()
    }
}
impl ErrorResponse {
    /// Protobuf type URL for this message, for use with `Any::pack` and
    /// `Any::unpack_if`.
    ///
    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
    pub const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ErrorResponse";
}
::buffa::impl_default_instance!(ErrorResponse);
impl ::buffa::MessageName for ErrorResponse {
    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 ::buffa::Message for ErrorResponse {
    /// Returns the total encoded size in bytes.
    ///
    /// Accumulates in `u64` (which cannot overflow for in-memory
    /// data) and saturates to `u32` at return, so a message whose
    /// encoded size exceeds the 2 GiB protobuf limit yields a value
    /// above [`::buffa::MAX_MESSAGE_BYTES`] that the encode entry
    /// points reject, never a silently wrapped size.
    #[allow(clippy::let_and_return)]
    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        let mut size = 0u64;
        if self.error_code != 0i32 {
            size += 1u64 + ::buffa::types::int32_encoded_len(self.error_code) as u64;
        }
        if !self.error_message.is_empty() {
            size
                += 1u64 + ::buffa::types::string_encoded_len(&self.error_message) as u64;
        }
        size += self.__buffa_unknown_fields.encoded_len() as u64;
        ::buffa::saturate_size(size)
    }
    fn write_to(
        &self,
        _cache: &mut ::buffa::SizeCache,
        buf: &mut impl ::buffa::EncodeSink,
    ) {
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        if self.error_code != 0i32 {
            ::buffa::types::put_int32_field(1u32, self.error_code, buf);
        }
        if !self.error_message.is_empty() {
            ::buffa::types::put_string_field(2u32, &self.error_message, buf);
        }
        self.__buffa_unknown_fields.write_to(buf);
    }
    fn merge_field(
        &mut self,
        tag: ::buffa::encoding::Tag,
        buf: &mut impl ::buffa::bytes::Buf,
        ctx: ::buffa::DecodeContext<'_>,
    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
        #[allow(unused_imports)]
        use ::buffa::bytes::Buf as _;
        #[allow(unused_imports)]
        use ::buffa::Enumeration as _;
        match tag.field_number() {
            1u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::Varint,
                )?;
                self.error_code = ::buffa::types::decode_int32(buf)?;
            }
            2u32 => {
                ::buffa::encoding::check_wire_type(
                    tag,
                    ::buffa::encoding::WireType::LengthDelimited,
                )?;
                ::buffa::types::merge_string(&mut self.error_message, buf)?;
            }
            _ => {
                self.__buffa_unknown_fields
                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
            }
        }
        ::core::result::Result::Ok(())
    }
    fn clear(&mut self) {
        self.error_code = 0i32;
        self.error_message.clear();
        self.__buffa_unknown_fields.clear();
    }
}
impl ::buffa::ExtensionSet for ErrorResponse {
    const PROTO_FQN: &'static str = "grpc.reflection.v1alpha.ErrorResponse";
    fn unknown_fields(&self) -> &::buffa::UnknownFields {
        &self.__buffa_unknown_fields
    }
    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
        &mut self.__buffa_unknown_fields
    }
}
impl ::buffa::json_helpers::ProtoElemJson for ErrorResponse {
    fn serialize_proto_json<S: ::serde::Serializer>(
        v: &Self,
        s: S,
    ) -> ::core::result::Result<S::Ok, S::Error> {
        ::serde::Serialize::serialize(v, s)
    }
    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
        d: D,
    ) -> ::core::result::Result<Self, D::Error> {
        <Self as ::serde::Deserialize>::deserialize(d)
    }
}
#[doc(hidden)]
pub const __ERROR_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
    type_url: "type.googleapis.com/grpc.reflection.v1alpha.ErrorResponse",
    to_json: ::buffa::type_registry::any_to_json::<ErrorResponse>,
    from_json: ::buffa::type_registry::any_from_json::<ErrorResponse>,
    is_wkt: false,
};