Skip to main content

connectrpc_reflection/generated/buffa/
grpc.reflection.v1alpha.reflection.rs

1// @generated by buffa-codegen. DO NOT EDIT.
2// source: grpc/reflection/v1alpha/reflection.proto
3
4/// The message sent by the client when calling ServerReflectionInfo method.
5#[derive(Clone, PartialEq, Default)]
6#[derive(::serde::Serialize)]
7#[serde(default)]
8pub struct ServerReflectionRequest {
9    /// Field 1: `host`
10    #[serde(
11        rename = "host",
12        with = "::buffa::json_helpers::proto_string",
13        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
14    )]
15    pub host: ::buffa::alloc::string::String,
16    #[serde(flatten)]
17    pub message_request: ::core::option::Option<
18        __buffa::oneof::server_reflection_request::MessageRequest,
19    >,
20    #[serde(skip)]
21    #[doc(hidden)]
22    pub __buffa_unknown_fields: ::buffa::UnknownFields,
23}
24impl ::core::fmt::Debug for ServerReflectionRequest {
25    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
26        f.debug_struct("ServerReflectionRequest")
27            .field("host", &self.host)
28            .field("message_request", &self.message_request)
29            .finish()
30    }
31}
32impl ServerReflectionRequest {
33    /// Protobuf type URL for this message, for use with `Any::pack` and
34    /// `Any::unpack_if`.
35    ///
36    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
37    pub const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ServerReflectionRequest";
38}
39::buffa::impl_default_instance!(ServerReflectionRequest);
40impl ::buffa::MessageName for ServerReflectionRequest {
41    const PACKAGE: &'static str = "grpc.reflection.v1alpha";
42    const NAME: &'static str = "ServerReflectionRequest";
43    const FULL_NAME: &'static str = "grpc.reflection.v1alpha.ServerReflectionRequest";
44    const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ServerReflectionRequest";
45}
46impl ::buffa::Message for ServerReflectionRequest {
47    /// Returns the total encoded size in bytes.
48    ///
49    /// The result is a `u32`; the protobuf specification requires all
50    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
51    /// compliant message will never overflow this type.
52    #[allow(clippy::let_and_return)]
53    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
54        #[allow(unused_imports)]
55        use ::buffa::Enumeration as _;
56        let mut size = 0u32;
57        if !self.host.is_empty() {
58            size += 1u32 + ::buffa::types::string_encoded_len(&self.host) as u32;
59        }
60        if let ::core::option::Option::Some(ref v) = self.message_request {
61            match v {
62                __buffa::oneof::server_reflection_request::MessageRequest::FileByFilename(
63                    x,
64                ) => {
65                    size += 1u32 + ::buffa::types::string_encoded_len(x) as u32;
66                }
67                __buffa::oneof::server_reflection_request::MessageRequest::FileContainingSymbol(
68                    x,
69                ) => {
70                    size += 1u32 + ::buffa::types::string_encoded_len(x) as u32;
71                }
72                __buffa::oneof::server_reflection_request::MessageRequest::FileContainingExtension(
73                    x,
74                ) => {
75                    let __slot = __cache.reserve();
76                    let inner = x.compute_size(__cache);
77                    __cache.set(__slot, inner);
78                    size
79                        += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
80                            + inner;
81                }
82                __buffa::oneof::server_reflection_request::MessageRequest::AllExtensionNumbersOfType(
83                    x,
84                ) => {
85                    size += 1u32 + ::buffa::types::string_encoded_len(x) as u32;
86                }
87                __buffa::oneof::server_reflection_request::MessageRequest::ListServices(
88                    x,
89                ) => {
90                    size += 1u32 + ::buffa::types::string_encoded_len(x) as u32;
91                }
92            }
93        }
94        size += self.__buffa_unknown_fields.encoded_len() as u32;
95        size
96    }
97    fn write_to(
98        &self,
99        __cache: &mut ::buffa::SizeCache,
100        buf: &mut impl ::buffa::bytes::BufMut,
101    ) {
102        #[allow(unused_imports)]
103        use ::buffa::Enumeration as _;
104        if !self.host.is_empty() {
105            ::buffa::types::put_string_field(1u32, &self.host, buf);
106        }
107        if let ::core::option::Option::Some(ref v) = self.message_request {
108            match v {
109                __buffa::oneof::server_reflection_request::MessageRequest::FileByFilename(
110                    x,
111                ) => {
112                    ::buffa::types::put_string_field(3u32, x, buf);
113                }
114                __buffa::oneof::server_reflection_request::MessageRequest::FileContainingSymbol(
115                    x,
116                ) => {
117                    ::buffa::types::put_string_field(4u32, x, buf);
118                }
119                __buffa::oneof::server_reflection_request::MessageRequest::FileContainingExtension(
120                    x,
121                ) => {
122                    ::buffa::types::put_len_delimited_header(
123                        5u32,
124                        __cache.consume_next(),
125                        buf,
126                    );
127                    x.write_to(__cache, buf);
128                }
129                __buffa::oneof::server_reflection_request::MessageRequest::AllExtensionNumbersOfType(
130                    x,
131                ) => {
132                    ::buffa::types::put_string_field(6u32, x, buf);
133                }
134                __buffa::oneof::server_reflection_request::MessageRequest::ListServices(
135                    x,
136                ) => {
137                    ::buffa::types::put_string_field(7u32, x, buf);
138                }
139            }
140        }
141        self.__buffa_unknown_fields.write_to(buf);
142    }
143    fn merge_field(
144        &mut self,
145        tag: ::buffa::encoding::Tag,
146        buf: &mut impl ::buffa::bytes::Buf,
147        ctx: ::buffa::DecodeContext<'_>,
148    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
149        #[allow(unused_imports)]
150        use ::buffa::bytes::Buf as _;
151        #[allow(unused_imports)]
152        use ::buffa::Enumeration as _;
153        match tag.field_number() {
154            1u32 => {
155                ::buffa::encoding::check_wire_type(
156                    tag,
157                    ::buffa::encoding::WireType::LengthDelimited,
158                )?;
159                ::buffa::types::merge_string(&mut self.host, buf)?;
160            }
161            3u32 => {
162                ::buffa::encoding::check_wire_type(
163                    tag,
164                    ::buffa::encoding::WireType::LengthDelimited,
165                )?;
166                self.message_request = ::core::option::Option::Some(
167                    __buffa::oneof::server_reflection_request::MessageRequest::FileByFilename(
168                        ::buffa::types::decode_string(buf)?,
169                    ),
170                );
171            }
172            4u32 => {
173                ::buffa::encoding::check_wire_type(
174                    tag,
175                    ::buffa::encoding::WireType::LengthDelimited,
176                )?;
177                self.message_request = ::core::option::Option::Some(
178                    __buffa::oneof::server_reflection_request::MessageRequest::FileContainingSymbol(
179                        ::buffa::types::decode_string(buf)?,
180                    ),
181                );
182            }
183            5u32 => {
184                ::buffa::encoding::check_wire_type(
185                    tag,
186                    ::buffa::encoding::WireType::LengthDelimited,
187                )?;
188                if let ::core::option::Option::Some(
189                    __buffa::oneof::server_reflection_request::MessageRequest::FileContainingExtension(
190                        ref mut existing,
191                    ),
192                ) = self.message_request
193                {
194                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
195                } else {
196                    let mut val = ::core::default::Default::default();
197                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
198                    self.message_request = ::core::option::Option::Some(
199                        __buffa::oneof::server_reflection_request::MessageRequest::FileContainingExtension(
200                            ::buffa::alloc::boxed::Box::new(val),
201                        ),
202                    );
203                }
204            }
205            6u32 => {
206                ::buffa::encoding::check_wire_type(
207                    tag,
208                    ::buffa::encoding::WireType::LengthDelimited,
209                )?;
210                self.message_request = ::core::option::Option::Some(
211                    __buffa::oneof::server_reflection_request::MessageRequest::AllExtensionNumbersOfType(
212                        ::buffa::types::decode_string(buf)?,
213                    ),
214                );
215            }
216            7u32 => {
217                ::buffa::encoding::check_wire_type(
218                    tag,
219                    ::buffa::encoding::WireType::LengthDelimited,
220                )?;
221                self.message_request = ::core::option::Option::Some(
222                    __buffa::oneof::server_reflection_request::MessageRequest::ListServices(
223                        ::buffa::types::decode_string(buf)?,
224                    ),
225                );
226            }
227            _ => {
228                self.__buffa_unknown_fields
229                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
230            }
231        }
232        ::core::result::Result::Ok(())
233    }
234    fn clear(&mut self) {
235        self.host.clear();
236        self.message_request = ::core::option::Option::None;
237        self.__buffa_unknown_fields.clear();
238    }
239}
240impl ::buffa::ExtensionSet for ServerReflectionRequest {
241    const PROTO_FQN: &'static str = "grpc.reflection.v1alpha.ServerReflectionRequest";
242    fn unknown_fields(&self) -> &::buffa::UnknownFields {
243        &self.__buffa_unknown_fields
244    }
245    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
246        &mut self.__buffa_unknown_fields
247    }
248}
249impl<'de> serde::Deserialize<'de> for ServerReflectionRequest {
250    fn deserialize<D: serde::Deserializer<'de>>(
251        d: D,
252    ) -> ::core::result::Result<Self, D::Error> {
253        struct _V;
254        impl<'de> serde::de::Visitor<'de> for _V {
255            type Value = ServerReflectionRequest;
256            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
257                f.write_str("struct ServerReflectionRequest")
258            }
259            #[allow(clippy::field_reassign_with_default)]
260            fn visit_map<A: serde::de::MapAccess<'de>>(
261                self,
262                mut map: A,
263            ) -> ::core::result::Result<ServerReflectionRequest, A::Error> {
264                let mut __f_host: ::core::option::Option<
265                    ::buffa::alloc::string::String,
266                > = None;
267                let mut __oneof_message_request: ::core::option::Option<
268                    __buffa::oneof::server_reflection_request::MessageRequest,
269                > = None;
270                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
271                    match key.as_str() {
272                        "host" => {
273                            __f_host = Some({
274                                struct _S;
275                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
276                                    type Value = ::buffa::alloc::string::String;
277                                    fn deserialize<D: serde::Deserializer<'de>>(
278                                        self,
279                                        d: D,
280                                    ) -> ::core::result::Result<
281                                        ::buffa::alloc::string::String,
282                                        D::Error,
283                                    > {
284                                        ::buffa::json_helpers::proto_string::deserialize(d)
285                                    }
286                                }
287                                map.next_value_seed(_S)?
288                            });
289                        }
290                        "fileByFilename" | "file_by_filename" => {
291                            let v: ::core::option::Option<
292                                ::buffa::alloc::string::String,
293                            > = map
294                                .next_value_seed(
295                                    ::buffa::json_helpers::NullableDeserializeSeed(
296                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
297                                            ::buffa::alloc::string::String,
298                                        >::new(),
299                                    ),
300                                )?;
301                            if let Some(v) = v {
302                                if __oneof_message_request.is_some() {
303                                    return Err(
304                                        serde::de::Error::custom(
305                                            "multiple oneof fields set for 'message_request'",
306                                        ),
307                                    );
308                                }
309                                __oneof_message_request = Some(
310                                    __buffa::oneof::server_reflection_request::MessageRequest::FileByFilename(
311                                        v,
312                                    ),
313                                );
314                            }
315                        }
316                        "fileContainingSymbol" | "file_containing_symbol" => {
317                            let v: ::core::option::Option<
318                                ::buffa::alloc::string::String,
319                            > = map
320                                .next_value_seed(
321                                    ::buffa::json_helpers::NullableDeserializeSeed(
322                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
323                                            ::buffa::alloc::string::String,
324                                        >::new(),
325                                    ),
326                                )?;
327                            if let Some(v) = v {
328                                if __oneof_message_request.is_some() {
329                                    return Err(
330                                        serde::de::Error::custom(
331                                            "multiple oneof fields set for 'message_request'",
332                                        ),
333                                    );
334                                }
335                                __oneof_message_request = Some(
336                                    __buffa::oneof::server_reflection_request::MessageRequest::FileContainingSymbol(
337                                        v,
338                                    ),
339                                );
340                            }
341                        }
342                        "fileContainingExtension" | "file_containing_extension" => {
343                            let v: ::core::option::Option<ExtensionRequest> = map
344                                .next_value_seed(
345                                    ::buffa::json_helpers::NullableDeserializeSeed(
346                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
347                                            ExtensionRequest,
348                                        >::new(),
349                                    ),
350                                )?;
351                            if let Some(v) = v {
352                                if __oneof_message_request.is_some() {
353                                    return Err(
354                                        serde::de::Error::custom(
355                                            "multiple oneof fields set for 'message_request'",
356                                        ),
357                                    );
358                                }
359                                __oneof_message_request = Some(
360                                    __buffa::oneof::server_reflection_request::MessageRequest::FileContainingExtension(
361                                        ::buffa::alloc::boxed::Box::new(v),
362                                    ),
363                                );
364                            }
365                        }
366                        "allExtensionNumbersOfType"
367                        | "all_extension_numbers_of_type" => {
368                            let v: ::core::option::Option<
369                                ::buffa::alloc::string::String,
370                            > = map
371                                .next_value_seed(
372                                    ::buffa::json_helpers::NullableDeserializeSeed(
373                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
374                                            ::buffa::alloc::string::String,
375                                        >::new(),
376                                    ),
377                                )?;
378                            if let Some(v) = v {
379                                if __oneof_message_request.is_some() {
380                                    return Err(
381                                        serde::de::Error::custom(
382                                            "multiple oneof fields set for 'message_request'",
383                                        ),
384                                    );
385                                }
386                                __oneof_message_request = Some(
387                                    __buffa::oneof::server_reflection_request::MessageRequest::AllExtensionNumbersOfType(
388                                        v,
389                                    ),
390                                );
391                            }
392                        }
393                        "listServices" | "list_services" => {
394                            let v: ::core::option::Option<
395                                ::buffa::alloc::string::String,
396                            > = map
397                                .next_value_seed(
398                                    ::buffa::json_helpers::NullableDeserializeSeed(
399                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
400                                            ::buffa::alloc::string::String,
401                                        >::new(),
402                                    ),
403                                )?;
404                            if let Some(v) = v {
405                                if __oneof_message_request.is_some() {
406                                    return Err(
407                                        serde::de::Error::custom(
408                                            "multiple oneof fields set for 'message_request'",
409                                        ),
410                                    );
411                                }
412                                __oneof_message_request = Some(
413                                    __buffa::oneof::server_reflection_request::MessageRequest::ListServices(
414                                        v,
415                                    ),
416                                );
417                            }
418                        }
419                        _ => {
420                            map.next_value::<serde::de::IgnoredAny>()?;
421                        }
422                    }
423                }
424                let mut __r = <ServerReflectionRequest as ::core::default::Default>::default();
425                if let ::core::option::Option::Some(v) = __f_host {
426                    __r.host = v;
427                }
428                __r.message_request = __oneof_message_request;
429                Ok(__r)
430            }
431        }
432        d.deserialize_map(_V)
433    }
434}
435impl ::buffa::json_helpers::ProtoElemJson for ServerReflectionRequest {
436    fn serialize_proto_json<S: ::serde::Serializer>(
437        v: &Self,
438        s: S,
439    ) -> ::core::result::Result<S::Ok, S::Error> {
440        ::serde::Serialize::serialize(v, s)
441    }
442    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
443        d: D,
444    ) -> ::core::result::Result<Self, D::Error> {
445        <Self as ::serde::Deserialize>::deserialize(d)
446    }
447}
448#[doc(hidden)]
449pub const __SERVER_REFLECTION_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
450    type_url: "type.googleapis.com/grpc.reflection.v1alpha.ServerReflectionRequest",
451    to_json: ::buffa::type_registry::any_to_json::<ServerReflectionRequest>,
452    from_json: ::buffa::type_registry::any_from_json::<ServerReflectionRequest>,
453    is_wkt: false,
454};
455pub mod server_reflection_request {
456    #[allow(unused_imports)]
457    use super::*;
458    #[doc(inline)]
459    pub use super::__buffa::oneof::server_reflection_request::MessageRequest;
460    #[doc(inline)]
461    pub use super::__buffa::view::oneof::server_reflection_request::MessageRequest as MessageRequestView;
462}
463/// The type name and extension number sent by the client when requesting
464/// file_containing_extension.
465#[derive(Clone, PartialEq, Default)]
466#[derive(::serde::Serialize, ::serde::Deserialize)]
467#[serde(default)]
468pub struct ExtensionRequest {
469    /// Fully-qualified type name. The format should be \<package\>.\<type\>
470    ///
471    /// Field 1: `containing_type`
472    #[serde(
473        rename = "containingType",
474        alias = "containing_type",
475        with = "::buffa::json_helpers::proto_string",
476        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
477    )]
478    pub containing_type: ::buffa::alloc::string::String,
479    /// Field 2: `extension_number`
480    #[serde(
481        rename = "extensionNumber",
482        alias = "extension_number",
483        with = "::buffa::json_helpers::int32",
484        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i32"
485    )]
486    pub extension_number: i32,
487    #[serde(skip)]
488    #[doc(hidden)]
489    pub __buffa_unknown_fields: ::buffa::UnknownFields,
490}
491impl ::core::fmt::Debug for ExtensionRequest {
492    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
493        f.debug_struct("ExtensionRequest")
494            .field("containing_type", &self.containing_type)
495            .field("extension_number", &self.extension_number)
496            .finish()
497    }
498}
499impl ExtensionRequest {
500    /// Protobuf type URL for this message, for use with `Any::pack` and
501    /// `Any::unpack_if`.
502    ///
503    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
504    pub const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ExtensionRequest";
505}
506::buffa::impl_default_instance!(ExtensionRequest);
507impl ::buffa::MessageName for ExtensionRequest {
508    const PACKAGE: &'static str = "grpc.reflection.v1alpha";
509    const NAME: &'static str = "ExtensionRequest";
510    const FULL_NAME: &'static str = "grpc.reflection.v1alpha.ExtensionRequest";
511    const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ExtensionRequest";
512}
513impl ::buffa::Message for ExtensionRequest {
514    /// Returns the total encoded size in bytes.
515    ///
516    /// The result is a `u32`; the protobuf specification requires all
517    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
518    /// compliant message will never overflow this type.
519    #[allow(clippy::let_and_return)]
520    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
521        #[allow(unused_imports)]
522        use ::buffa::Enumeration as _;
523        let mut size = 0u32;
524        if !self.containing_type.is_empty() {
525            size
526                += 1u32
527                    + ::buffa::types::string_encoded_len(&self.containing_type) as u32;
528        }
529        if self.extension_number != 0i32 {
530            size
531                += 1u32
532                    + ::buffa::types::int32_encoded_len(self.extension_number) as u32;
533        }
534        size += self.__buffa_unknown_fields.encoded_len() as u32;
535        size
536    }
537    fn write_to(
538        &self,
539        _cache: &mut ::buffa::SizeCache,
540        buf: &mut impl ::buffa::bytes::BufMut,
541    ) {
542        #[allow(unused_imports)]
543        use ::buffa::Enumeration as _;
544        if !self.containing_type.is_empty() {
545            ::buffa::types::put_string_field(1u32, &self.containing_type, buf);
546        }
547        if self.extension_number != 0i32 {
548            ::buffa::types::put_int32_field(2u32, self.extension_number, buf);
549        }
550        self.__buffa_unknown_fields.write_to(buf);
551    }
552    fn merge_field(
553        &mut self,
554        tag: ::buffa::encoding::Tag,
555        buf: &mut impl ::buffa::bytes::Buf,
556        ctx: ::buffa::DecodeContext<'_>,
557    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
558        #[allow(unused_imports)]
559        use ::buffa::bytes::Buf as _;
560        #[allow(unused_imports)]
561        use ::buffa::Enumeration as _;
562        match tag.field_number() {
563            1u32 => {
564                ::buffa::encoding::check_wire_type(
565                    tag,
566                    ::buffa::encoding::WireType::LengthDelimited,
567                )?;
568                ::buffa::types::merge_string(&mut self.containing_type, buf)?;
569            }
570            2u32 => {
571                ::buffa::encoding::check_wire_type(
572                    tag,
573                    ::buffa::encoding::WireType::Varint,
574                )?;
575                self.extension_number = ::buffa::types::decode_int32(buf)?;
576            }
577            _ => {
578                self.__buffa_unknown_fields
579                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
580            }
581        }
582        ::core::result::Result::Ok(())
583    }
584    fn clear(&mut self) {
585        self.containing_type.clear();
586        self.extension_number = 0i32;
587        self.__buffa_unknown_fields.clear();
588    }
589}
590impl ::buffa::ExtensionSet for ExtensionRequest {
591    const PROTO_FQN: &'static str = "grpc.reflection.v1alpha.ExtensionRequest";
592    fn unknown_fields(&self) -> &::buffa::UnknownFields {
593        &self.__buffa_unknown_fields
594    }
595    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
596        &mut self.__buffa_unknown_fields
597    }
598}
599impl ::buffa::json_helpers::ProtoElemJson for ExtensionRequest {
600    fn serialize_proto_json<S: ::serde::Serializer>(
601        v: &Self,
602        s: S,
603    ) -> ::core::result::Result<S::Ok, S::Error> {
604        ::serde::Serialize::serialize(v, s)
605    }
606    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
607        d: D,
608    ) -> ::core::result::Result<Self, D::Error> {
609        <Self as ::serde::Deserialize>::deserialize(d)
610    }
611}
612#[doc(hidden)]
613pub const __EXTENSION_REQUEST_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
614    type_url: "type.googleapis.com/grpc.reflection.v1alpha.ExtensionRequest",
615    to_json: ::buffa::type_registry::any_to_json::<ExtensionRequest>,
616    from_json: ::buffa::type_registry::any_from_json::<ExtensionRequest>,
617    is_wkt: false,
618};
619/// The message sent by the server to answer ServerReflectionInfo method.
620#[derive(Clone, PartialEq, Default)]
621#[derive(::serde::Serialize)]
622#[serde(default)]
623pub struct ServerReflectionResponse {
624    /// Field 1: `valid_host`
625    #[serde(
626        rename = "validHost",
627        alias = "valid_host",
628        with = "::buffa::json_helpers::proto_string",
629        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
630    )]
631    pub valid_host: ::buffa::alloc::string::String,
632    /// Field 2: `original_request`
633    #[serde(
634        rename = "originalRequest",
635        alias = "original_request",
636        skip_serializing_if = "::buffa::json_helpers::skip_if::is_unset_message_field"
637    )]
638    pub original_request: ::buffa::MessageField<ServerReflectionRequest>,
639    #[serde(flatten)]
640    pub message_response: ::core::option::Option<
641        __buffa::oneof::server_reflection_response::MessageResponse,
642    >,
643    #[serde(skip)]
644    #[doc(hidden)]
645    pub __buffa_unknown_fields: ::buffa::UnknownFields,
646}
647impl ::core::fmt::Debug for ServerReflectionResponse {
648    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
649        f.debug_struct("ServerReflectionResponse")
650            .field("valid_host", &self.valid_host)
651            .field("original_request", &self.original_request)
652            .field("message_response", &self.message_response)
653            .finish()
654    }
655}
656impl ServerReflectionResponse {
657    /// Protobuf type URL for this message, for use with `Any::pack` and
658    /// `Any::unpack_if`.
659    ///
660    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
661    pub const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ServerReflectionResponse";
662}
663::buffa::impl_default_instance!(ServerReflectionResponse);
664impl ::buffa::MessageName for ServerReflectionResponse {
665    const PACKAGE: &'static str = "grpc.reflection.v1alpha";
666    const NAME: &'static str = "ServerReflectionResponse";
667    const FULL_NAME: &'static str = "grpc.reflection.v1alpha.ServerReflectionResponse";
668    const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ServerReflectionResponse";
669}
670impl ::buffa::Message for ServerReflectionResponse {
671    /// Returns the total encoded size in bytes.
672    ///
673    /// The result is a `u32`; the protobuf specification requires all
674    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
675    /// compliant message will never overflow this type.
676    #[allow(clippy::let_and_return)]
677    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
678        #[allow(unused_imports)]
679        use ::buffa::Enumeration as _;
680        let mut size = 0u32;
681        if !self.valid_host.is_empty() {
682            size += 1u32 + ::buffa::types::string_encoded_len(&self.valid_host) as u32;
683        }
684        if self.original_request.is_set() {
685            let __slot = __cache.reserve();
686            let inner_size = self.original_request.compute_size(__cache);
687            __cache.set(__slot, inner_size);
688            size
689                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
690                    + inner_size;
691        }
692        if let ::core::option::Option::Some(ref v) = self.message_response {
693            match v {
694                __buffa::oneof::server_reflection_response::MessageResponse::FileDescriptorResponse(
695                    x,
696                ) => {
697                    let __slot = __cache.reserve();
698                    let inner = x.compute_size(__cache);
699                    __cache.set(__slot, inner);
700                    size
701                        += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
702                            + inner;
703                }
704                __buffa::oneof::server_reflection_response::MessageResponse::AllExtensionNumbersResponse(
705                    x,
706                ) => {
707                    let __slot = __cache.reserve();
708                    let inner = x.compute_size(__cache);
709                    __cache.set(__slot, inner);
710                    size
711                        += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
712                            + inner;
713                }
714                __buffa::oneof::server_reflection_response::MessageResponse::ListServicesResponse(
715                    x,
716                ) => {
717                    let __slot = __cache.reserve();
718                    let inner = x.compute_size(__cache);
719                    __cache.set(__slot, inner);
720                    size
721                        += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
722                            + inner;
723                }
724                __buffa::oneof::server_reflection_response::MessageResponse::ErrorResponse(
725                    x,
726                ) => {
727                    let __slot = __cache.reserve();
728                    let inner = x.compute_size(__cache);
729                    __cache.set(__slot, inner);
730                    size
731                        += 1u32 + ::buffa::encoding::varint_len(inner as u64) as u32
732                            + inner;
733                }
734            }
735        }
736        size += self.__buffa_unknown_fields.encoded_len() as u32;
737        size
738    }
739    fn write_to(
740        &self,
741        __cache: &mut ::buffa::SizeCache,
742        buf: &mut impl ::buffa::bytes::BufMut,
743    ) {
744        #[allow(unused_imports)]
745        use ::buffa::Enumeration as _;
746        if !self.valid_host.is_empty() {
747            ::buffa::types::put_string_field(1u32, &self.valid_host, buf);
748        }
749        if self.original_request.is_set() {
750            ::buffa::types::put_len_delimited_header(2u32, __cache.consume_next(), buf);
751            self.original_request.write_to(__cache, buf);
752        }
753        if let ::core::option::Option::Some(ref v) = self.message_response {
754            match v {
755                __buffa::oneof::server_reflection_response::MessageResponse::FileDescriptorResponse(
756                    x,
757                ) => {
758                    ::buffa::types::put_len_delimited_header(
759                        4u32,
760                        __cache.consume_next(),
761                        buf,
762                    );
763                    x.write_to(__cache, buf);
764                }
765                __buffa::oneof::server_reflection_response::MessageResponse::AllExtensionNumbersResponse(
766                    x,
767                ) => {
768                    ::buffa::types::put_len_delimited_header(
769                        5u32,
770                        __cache.consume_next(),
771                        buf,
772                    );
773                    x.write_to(__cache, buf);
774                }
775                __buffa::oneof::server_reflection_response::MessageResponse::ListServicesResponse(
776                    x,
777                ) => {
778                    ::buffa::types::put_len_delimited_header(
779                        6u32,
780                        __cache.consume_next(),
781                        buf,
782                    );
783                    x.write_to(__cache, buf);
784                }
785                __buffa::oneof::server_reflection_response::MessageResponse::ErrorResponse(
786                    x,
787                ) => {
788                    ::buffa::types::put_len_delimited_header(
789                        7u32,
790                        __cache.consume_next(),
791                        buf,
792                    );
793                    x.write_to(__cache, buf);
794                }
795            }
796        }
797        self.__buffa_unknown_fields.write_to(buf);
798    }
799    fn merge_field(
800        &mut self,
801        tag: ::buffa::encoding::Tag,
802        buf: &mut impl ::buffa::bytes::Buf,
803        ctx: ::buffa::DecodeContext<'_>,
804    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
805        #[allow(unused_imports)]
806        use ::buffa::bytes::Buf as _;
807        #[allow(unused_imports)]
808        use ::buffa::Enumeration as _;
809        match tag.field_number() {
810            1u32 => {
811                ::buffa::encoding::check_wire_type(
812                    tag,
813                    ::buffa::encoding::WireType::LengthDelimited,
814                )?;
815                ::buffa::types::merge_string(&mut self.valid_host, buf)?;
816            }
817            2u32 => {
818                ::buffa::encoding::check_wire_type(
819                    tag,
820                    ::buffa::encoding::WireType::LengthDelimited,
821                )?;
822                ::buffa::Message::merge_length_delimited(
823                    self.original_request.get_or_insert_default(),
824                    buf,
825                    ctx,
826                )?;
827            }
828            4u32 => {
829                ::buffa::encoding::check_wire_type(
830                    tag,
831                    ::buffa::encoding::WireType::LengthDelimited,
832                )?;
833                if let ::core::option::Option::Some(
834                    __buffa::oneof::server_reflection_response::MessageResponse::FileDescriptorResponse(
835                        ref mut existing,
836                    ),
837                ) = self.message_response
838                {
839                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
840                } else {
841                    let mut val = ::core::default::Default::default();
842                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
843                    self.message_response = ::core::option::Option::Some(
844                        __buffa::oneof::server_reflection_response::MessageResponse::FileDescriptorResponse(
845                            ::buffa::alloc::boxed::Box::new(val),
846                        ),
847                    );
848                }
849            }
850            5u32 => {
851                ::buffa::encoding::check_wire_type(
852                    tag,
853                    ::buffa::encoding::WireType::LengthDelimited,
854                )?;
855                if let ::core::option::Option::Some(
856                    __buffa::oneof::server_reflection_response::MessageResponse::AllExtensionNumbersResponse(
857                        ref mut existing,
858                    ),
859                ) = self.message_response
860                {
861                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
862                } else {
863                    let mut val = ::core::default::Default::default();
864                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
865                    self.message_response = ::core::option::Option::Some(
866                        __buffa::oneof::server_reflection_response::MessageResponse::AllExtensionNumbersResponse(
867                            ::buffa::alloc::boxed::Box::new(val),
868                        ),
869                    );
870                }
871            }
872            6u32 => {
873                ::buffa::encoding::check_wire_type(
874                    tag,
875                    ::buffa::encoding::WireType::LengthDelimited,
876                )?;
877                if let ::core::option::Option::Some(
878                    __buffa::oneof::server_reflection_response::MessageResponse::ListServicesResponse(
879                        ref mut existing,
880                    ),
881                ) = self.message_response
882                {
883                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
884                } else {
885                    let mut val = ::core::default::Default::default();
886                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
887                    self.message_response = ::core::option::Option::Some(
888                        __buffa::oneof::server_reflection_response::MessageResponse::ListServicesResponse(
889                            ::buffa::alloc::boxed::Box::new(val),
890                        ),
891                    );
892                }
893            }
894            7u32 => {
895                ::buffa::encoding::check_wire_type(
896                    tag,
897                    ::buffa::encoding::WireType::LengthDelimited,
898                )?;
899                if let ::core::option::Option::Some(
900                    __buffa::oneof::server_reflection_response::MessageResponse::ErrorResponse(
901                        ref mut existing,
902                    ),
903                ) = self.message_response
904                {
905                    ::buffa::Message::merge_length_delimited(&mut **existing, buf, ctx)?;
906                } else {
907                    let mut val = ::core::default::Default::default();
908                    ::buffa::Message::merge_length_delimited(&mut val, buf, ctx)?;
909                    self.message_response = ::core::option::Option::Some(
910                        __buffa::oneof::server_reflection_response::MessageResponse::ErrorResponse(
911                            ::buffa::alloc::boxed::Box::new(val),
912                        ),
913                    );
914                }
915            }
916            _ => {
917                self.__buffa_unknown_fields
918                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
919            }
920        }
921        ::core::result::Result::Ok(())
922    }
923    fn clear(&mut self) {
924        self.valid_host.clear();
925        self.original_request = ::buffa::MessageField::none();
926        self.message_response = ::core::option::Option::None;
927        self.__buffa_unknown_fields.clear();
928    }
929}
930impl ::buffa::ExtensionSet for ServerReflectionResponse {
931    const PROTO_FQN: &'static str = "grpc.reflection.v1alpha.ServerReflectionResponse";
932    fn unknown_fields(&self) -> &::buffa::UnknownFields {
933        &self.__buffa_unknown_fields
934    }
935    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
936        &mut self.__buffa_unknown_fields
937    }
938}
939impl<'de> serde::Deserialize<'de> for ServerReflectionResponse {
940    fn deserialize<D: serde::Deserializer<'de>>(
941        d: D,
942    ) -> ::core::result::Result<Self, D::Error> {
943        struct _V;
944        impl<'de> serde::de::Visitor<'de> for _V {
945            type Value = ServerReflectionResponse;
946            fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
947                f.write_str("struct ServerReflectionResponse")
948            }
949            #[allow(clippy::field_reassign_with_default)]
950            fn visit_map<A: serde::de::MapAccess<'de>>(
951                self,
952                mut map: A,
953            ) -> ::core::result::Result<ServerReflectionResponse, A::Error> {
954                let mut __f_valid_host: ::core::option::Option<
955                    ::buffa::alloc::string::String,
956                > = None;
957                let mut __f_original_request: ::core::option::Option<
958                    ::buffa::MessageField<ServerReflectionRequest>,
959                > = None;
960                let mut __oneof_message_response: ::core::option::Option<
961                    __buffa::oneof::server_reflection_response::MessageResponse,
962                > = None;
963                while let Some(key) = map.next_key::<::buffa::alloc::string::String>()? {
964                    match key.as_str() {
965                        "validHost" | "valid_host" => {
966                            __f_valid_host = Some({
967                                struct _S;
968                                impl<'de> serde::de::DeserializeSeed<'de> for _S {
969                                    type Value = ::buffa::alloc::string::String;
970                                    fn deserialize<D: serde::Deserializer<'de>>(
971                                        self,
972                                        d: D,
973                                    ) -> ::core::result::Result<
974                                        ::buffa::alloc::string::String,
975                                        D::Error,
976                                    > {
977                                        ::buffa::json_helpers::proto_string::deserialize(d)
978                                    }
979                                }
980                                map.next_value_seed(_S)?
981                            });
982                        }
983                        "originalRequest" | "original_request" => {
984                            __f_original_request = Some(
985                                map
986                                    .next_value::<
987                                        ::buffa::MessageField<ServerReflectionRequest>,
988                                    >()?,
989                            );
990                        }
991                        "fileDescriptorResponse" | "file_descriptor_response" => {
992                            let v: ::core::option::Option<FileDescriptorResponse> = map
993                                .next_value_seed(
994                                    ::buffa::json_helpers::NullableDeserializeSeed(
995                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
996                                            FileDescriptorResponse,
997                                        >::new(),
998                                    ),
999                                )?;
1000                            if let Some(v) = v {
1001                                if __oneof_message_response.is_some() {
1002                                    return Err(
1003                                        serde::de::Error::custom(
1004                                            "multiple oneof fields set for 'message_response'",
1005                                        ),
1006                                    );
1007                                }
1008                                __oneof_message_response = Some(
1009                                    __buffa::oneof::server_reflection_response::MessageResponse::FileDescriptorResponse(
1010                                        ::buffa::alloc::boxed::Box::new(v),
1011                                    ),
1012                                );
1013                            }
1014                        }
1015                        "allExtensionNumbersResponse"
1016                        | "all_extension_numbers_response" => {
1017                            let v: ::core::option::Option<ExtensionNumberResponse> = map
1018                                .next_value_seed(
1019                                    ::buffa::json_helpers::NullableDeserializeSeed(
1020                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
1021                                            ExtensionNumberResponse,
1022                                        >::new(),
1023                                    ),
1024                                )?;
1025                            if let Some(v) = v {
1026                                if __oneof_message_response.is_some() {
1027                                    return Err(
1028                                        serde::de::Error::custom(
1029                                            "multiple oneof fields set for 'message_response'",
1030                                        ),
1031                                    );
1032                                }
1033                                __oneof_message_response = Some(
1034                                    __buffa::oneof::server_reflection_response::MessageResponse::AllExtensionNumbersResponse(
1035                                        ::buffa::alloc::boxed::Box::new(v),
1036                                    ),
1037                                );
1038                            }
1039                        }
1040                        "listServicesResponse" | "list_services_response" => {
1041                            let v: ::core::option::Option<ListServiceResponse> = map
1042                                .next_value_seed(
1043                                    ::buffa::json_helpers::NullableDeserializeSeed(
1044                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
1045                                            ListServiceResponse,
1046                                        >::new(),
1047                                    ),
1048                                )?;
1049                            if let Some(v) = v {
1050                                if __oneof_message_response.is_some() {
1051                                    return Err(
1052                                        serde::de::Error::custom(
1053                                            "multiple oneof fields set for 'message_response'",
1054                                        ),
1055                                    );
1056                                }
1057                                __oneof_message_response = Some(
1058                                    __buffa::oneof::server_reflection_response::MessageResponse::ListServicesResponse(
1059                                        ::buffa::alloc::boxed::Box::new(v),
1060                                    ),
1061                                );
1062                            }
1063                        }
1064                        "errorResponse" | "error_response" => {
1065                            let v: ::core::option::Option<ErrorResponse> = map
1066                                .next_value_seed(
1067                                    ::buffa::json_helpers::NullableDeserializeSeed(
1068                                        ::buffa::json_helpers::DefaultDeserializeSeed::<
1069                                            ErrorResponse,
1070                                        >::new(),
1071                                    ),
1072                                )?;
1073                            if let Some(v) = v {
1074                                if __oneof_message_response.is_some() {
1075                                    return Err(
1076                                        serde::de::Error::custom(
1077                                            "multiple oneof fields set for 'message_response'",
1078                                        ),
1079                                    );
1080                                }
1081                                __oneof_message_response = Some(
1082                                    __buffa::oneof::server_reflection_response::MessageResponse::ErrorResponse(
1083                                        ::buffa::alloc::boxed::Box::new(v),
1084                                    ),
1085                                );
1086                            }
1087                        }
1088                        _ => {
1089                            map.next_value::<serde::de::IgnoredAny>()?;
1090                        }
1091                    }
1092                }
1093                let mut __r = <ServerReflectionResponse as ::core::default::Default>::default();
1094                if let ::core::option::Option::Some(v) = __f_valid_host {
1095                    __r.valid_host = v;
1096                }
1097                if let ::core::option::Option::Some(v) = __f_original_request {
1098                    __r.original_request = v;
1099                }
1100                __r.message_response = __oneof_message_response;
1101                Ok(__r)
1102            }
1103        }
1104        d.deserialize_map(_V)
1105    }
1106}
1107impl ::buffa::json_helpers::ProtoElemJson for ServerReflectionResponse {
1108    fn serialize_proto_json<S: ::serde::Serializer>(
1109        v: &Self,
1110        s: S,
1111    ) -> ::core::result::Result<S::Ok, S::Error> {
1112        ::serde::Serialize::serialize(v, s)
1113    }
1114    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1115        d: D,
1116    ) -> ::core::result::Result<Self, D::Error> {
1117        <Self as ::serde::Deserialize>::deserialize(d)
1118    }
1119}
1120#[doc(hidden)]
1121pub const __SERVER_REFLECTION_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1122    type_url: "type.googleapis.com/grpc.reflection.v1alpha.ServerReflectionResponse",
1123    to_json: ::buffa::type_registry::any_to_json::<ServerReflectionResponse>,
1124    from_json: ::buffa::type_registry::any_from_json::<ServerReflectionResponse>,
1125    is_wkt: false,
1126};
1127pub mod server_reflection_response {
1128    #[allow(unused_imports)]
1129    use super::*;
1130    #[doc(inline)]
1131    pub use super::__buffa::oneof::server_reflection_response::MessageResponse;
1132    #[doc(inline)]
1133    pub use super::__buffa::view::oneof::server_reflection_response::MessageResponse as MessageResponseView;
1134}
1135/// Serialized FileDescriptorProto messages sent by the server answering
1136/// a file_by_filename, file_containing_symbol, or file_containing_extension
1137/// request.
1138#[derive(Clone, PartialEq, Default)]
1139#[derive(::serde::Serialize, ::serde::Deserialize)]
1140#[serde(default)]
1141pub struct FileDescriptorResponse {
1142    /// Serialized FileDescriptorProto messages. We avoid taking a dependency on
1143    /// descriptor.proto, which uses proto2 only features, by making them opaque
1144    /// bytes instead.
1145    ///
1146    /// Field 1: `file_descriptor_proto`
1147    #[serde(
1148        rename = "fileDescriptorProto",
1149        alias = "file_descriptor_proto",
1150        with = "::buffa::json_helpers::proto_seq",
1151        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec"
1152    )]
1153    pub file_descriptor_proto: ::buffa::alloc::vec::Vec<::buffa::alloc::vec::Vec<u8>>,
1154    #[serde(skip)]
1155    #[doc(hidden)]
1156    pub __buffa_unknown_fields: ::buffa::UnknownFields,
1157}
1158impl ::core::fmt::Debug for FileDescriptorResponse {
1159    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1160        f.debug_struct("FileDescriptorResponse")
1161            .field("file_descriptor_proto", &self.file_descriptor_proto)
1162            .finish()
1163    }
1164}
1165impl FileDescriptorResponse {
1166    /// Protobuf type URL for this message, for use with `Any::pack` and
1167    /// `Any::unpack_if`.
1168    ///
1169    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
1170    pub const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.FileDescriptorResponse";
1171}
1172::buffa::impl_default_instance!(FileDescriptorResponse);
1173impl ::buffa::MessageName for FileDescriptorResponse {
1174    const PACKAGE: &'static str = "grpc.reflection.v1alpha";
1175    const NAME: &'static str = "FileDescriptorResponse";
1176    const FULL_NAME: &'static str = "grpc.reflection.v1alpha.FileDescriptorResponse";
1177    const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.FileDescriptorResponse";
1178}
1179impl ::buffa::Message for FileDescriptorResponse {
1180    /// Returns the total encoded size in bytes.
1181    ///
1182    /// The result is a `u32`; the protobuf specification requires all
1183    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
1184    /// compliant message will never overflow this type.
1185    #[allow(clippy::let_and_return)]
1186    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
1187        #[allow(unused_imports)]
1188        use ::buffa::Enumeration as _;
1189        let mut size = 0u32;
1190        for v in &self.file_descriptor_proto {
1191            size += 1u32 + ::buffa::types::bytes_encoded_len(v) as u32;
1192        }
1193        size += self.__buffa_unknown_fields.encoded_len() as u32;
1194        size
1195    }
1196    fn write_to(
1197        &self,
1198        _cache: &mut ::buffa::SizeCache,
1199        buf: &mut impl ::buffa::bytes::BufMut,
1200    ) {
1201        #[allow(unused_imports)]
1202        use ::buffa::Enumeration as _;
1203        for v in &self.file_descriptor_proto {
1204            ::buffa::types::put_bytes_field(1u32, v, buf);
1205        }
1206        self.__buffa_unknown_fields.write_to(buf);
1207    }
1208    fn merge_field(
1209        &mut self,
1210        tag: ::buffa::encoding::Tag,
1211        buf: &mut impl ::buffa::bytes::Buf,
1212        ctx: ::buffa::DecodeContext<'_>,
1213    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1214        #[allow(unused_imports)]
1215        use ::buffa::bytes::Buf as _;
1216        #[allow(unused_imports)]
1217        use ::buffa::Enumeration as _;
1218        match tag.field_number() {
1219            1u32 => {
1220                ::buffa::encoding::check_wire_type(
1221                    tag,
1222                    ::buffa::encoding::WireType::LengthDelimited,
1223                )?;
1224                self.file_descriptor_proto.push(::buffa::types::decode_bytes(buf)?);
1225            }
1226            _ => {
1227                self.__buffa_unknown_fields
1228                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
1229            }
1230        }
1231        ::core::result::Result::Ok(())
1232    }
1233    fn clear(&mut self) {
1234        self.file_descriptor_proto.clear();
1235        self.__buffa_unknown_fields.clear();
1236    }
1237}
1238impl ::buffa::ExtensionSet for FileDescriptorResponse {
1239    const PROTO_FQN: &'static str = "grpc.reflection.v1alpha.FileDescriptorResponse";
1240    fn unknown_fields(&self) -> &::buffa::UnknownFields {
1241        &self.__buffa_unknown_fields
1242    }
1243    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
1244        &mut self.__buffa_unknown_fields
1245    }
1246}
1247impl ::buffa::json_helpers::ProtoElemJson for FileDescriptorResponse {
1248    fn serialize_proto_json<S: ::serde::Serializer>(
1249        v: &Self,
1250        s: S,
1251    ) -> ::core::result::Result<S::Ok, S::Error> {
1252        ::serde::Serialize::serialize(v, s)
1253    }
1254    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1255        d: D,
1256    ) -> ::core::result::Result<Self, D::Error> {
1257        <Self as ::serde::Deserialize>::deserialize(d)
1258    }
1259}
1260#[doc(hidden)]
1261pub const __FILE_DESCRIPTOR_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1262    type_url: "type.googleapis.com/grpc.reflection.v1alpha.FileDescriptorResponse",
1263    to_json: ::buffa::type_registry::any_to_json::<FileDescriptorResponse>,
1264    from_json: ::buffa::type_registry::any_from_json::<FileDescriptorResponse>,
1265    is_wkt: false,
1266};
1267/// A list of extension numbers sent by the server answering
1268/// all_extension_numbers_of_type request.
1269#[derive(Clone, PartialEq, Default)]
1270#[derive(::serde::Serialize, ::serde::Deserialize)]
1271#[serde(default)]
1272pub struct ExtensionNumberResponse {
1273    /// Full name of the base type, including the package name. The format
1274    /// is \<package\>.\<type\>
1275    ///
1276    /// Field 1: `base_type_name`
1277    #[serde(
1278        rename = "baseTypeName",
1279        alias = "base_type_name",
1280        with = "::buffa::json_helpers::proto_string",
1281        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
1282    )]
1283    pub base_type_name: ::buffa::alloc::string::String,
1284    /// Field 2: `extension_number`
1285    #[serde(
1286        rename = "extensionNumber",
1287        alias = "extension_number",
1288        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
1289        deserialize_with = "::buffa::json_helpers::null_as_default"
1290    )]
1291    pub extension_number: ::buffa::alloc::vec::Vec<i32>,
1292    #[serde(skip)]
1293    #[doc(hidden)]
1294    pub __buffa_unknown_fields: ::buffa::UnknownFields,
1295}
1296impl ::core::fmt::Debug for ExtensionNumberResponse {
1297    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1298        f.debug_struct("ExtensionNumberResponse")
1299            .field("base_type_name", &self.base_type_name)
1300            .field("extension_number", &self.extension_number)
1301            .finish()
1302    }
1303}
1304impl ExtensionNumberResponse {
1305    /// Protobuf type URL for this message, for use with `Any::pack` and
1306    /// `Any::unpack_if`.
1307    ///
1308    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
1309    pub const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ExtensionNumberResponse";
1310}
1311::buffa::impl_default_instance!(ExtensionNumberResponse);
1312impl ::buffa::MessageName for ExtensionNumberResponse {
1313    const PACKAGE: &'static str = "grpc.reflection.v1alpha";
1314    const NAME: &'static str = "ExtensionNumberResponse";
1315    const FULL_NAME: &'static str = "grpc.reflection.v1alpha.ExtensionNumberResponse";
1316    const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ExtensionNumberResponse";
1317}
1318impl ::buffa::Message for ExtensionNumberResponse {
1319    /// Returns the total encoded size in bytes.
1320    ///
1321    /// The result is a `u32`; the protobuf specification requires all
1322    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
1323    /// compliant message will never overflow this type.
1324    #[allow(clippy::let_and_return)]
1325    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
1326        #[allow(unused_imports)]
1327        use ::buffa::Enumeration as _;
1328        let mut size = 0u32;
1329        if !self.base_type_name.is_empty() {
1330            size
1331                += 1u32
1332                    + ::buffa::types::string_encoded_len(&self.base_type_name) as u32;
1333        }
1334        if !self.extension_number.is_empty() {
1335            let payload: u32 = self
1336                .extension_number
1337                .iter()
1338                .map(|&v| ::buffa::types::int32_encoded_len(v) as u32)
1339                .sum::<u32>();
1340            size
1341                += 1u32 + ::buffa::encoding::varint_len(payload as u64) as u32 + payload;
1342        }
1343        size += self.__buffa_unknown_fields.encoded_len() as u32;
1344        size
1345    }
1346    fn write_to(
1347        &self,
1348        _cache: &mut ::buffa::SizeCache,
1349        buf: &mut impl ::buffa::bytes::BufMut,
1350    ) {
1351        #[allow(unused_imports)]
1352        use ::buffa::Enumeration as _;
1353        if !self.base_type_name.is_empty() {
1354            ::buffa::types::put_string_field(1u32, &self.base_type_name, buf);
1355        }
1356        if !self.extension_number.is_empty() {
1357            let payload: u32 = self
1358                .extension_number
1359                .iter()
1360                .map(|&v| ::buffa::types::int32_encoded_len(v) as u32)
1361                .sum::<u32>();
1362            ::buffa::types::put_len_delimited_header(2u32, payload, buf);
1363            for &v in &self.extension_number {
1364                ::buffa::types::encode_int32(v, buf);
1365            }
1366        }
1367        self.__buffa_unknown_fields.write_to(buf);
1368    }
1369    fn merge_field(
1370        &mut self,
1371        tag: ::buffa::encoding::Tag,
1372        buf: &mut impl ::buffa::bytes::Buf,
1373        ctx: ::buffa::DecodeContext<'_>,
1374    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1375        #[allow(unused_imports)]
1376        use ::buffa::bytes::Buf as _;
1377        #[allow(unused_imports)]
1378        use ::buffa::Enumeration as _;
1379        match tag.field_number() {
1380            1u32 => {
1381                ::buffa::encoding::check_wire_type(
1382                    tag,
1383                    ::buffa::encoding::WireType::LengthDelimited,
1384                )?;
1385                ::buffa::types::merge_string(&mut self.base_type_name, buf)?;
1386            }
1387            2u32 => {
1388                if tag.wire_type() == ::buffa::encoding::WireType::LengthDelimited {
1389                    let len = ::buffa::encoding::decode_varint(buf)?;
1390                    let len = usize::try_from(len)
1391                        .map_err(|_| ::buffa::DecodeError::MessageTooLarge)?;
1392                    if buf.remaining() < len {
1393                        return ::core::result::Result::Err(
1394                            ::buffa::DecodeError::UnexpectedEof,
1395                        );
1396                    }
1397                    self.extension_number.reserve(len);
1398                    let mut limited = buf.take(len);
1399                    while limited.has_remaining() {
1400                        self.extension_number
1401                            .push(::buffa::types::decode_int32(&mut limited)?);
1402                    }
1403                    let leftover = limited.remaining();
1404                    if leftover > 0 {
1405                        limited.advance(leftover);
1406                    }
1407                } else if tag.wire_type() == ::buffa::encoding::WireType::Varint {
1408                    self.extension_number.push(::buffa::types::decode_int32(buf)?);
1409                } else {
1410                    return ::core::result::Result::Err(
1411                        ::buffa::encoding::wire_type_mismatch(
1412                            tag,
1413                            ::buffa::encoding::WireType::LengthDelimited,
1414                        ),
1415                    );
1416                }
1417            }
1418            _ => {
1419                self.__buffa_unknown_fields
1420                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
1421            }
1422        }
1423        ::core::result::Result::Ok(())
1424    }
1425    fn clear(&mut self) {
1426        self.base_type_name.clear();
1427        self.extension_number.clear();
1428        self.__buffa_unknown_fields.clear();
1429    }
1430}
1431impl ::buffa::ExtensionSet for ExtensionNumberResponse {
1432    const PROTO_FQN: &'static str = "grpc.reflection.v1alpha.ExtensionNumberResponse";
1433    fn unknown_fields(&self) -> &::buffa::UnknownFields {
1434        &self.__buffa_unknown_fields
1435    }
1436    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
1437        &mut self.__buffa_unknown_fields
1438    }
1439}
1440impl ::buffa::json_helpers::ProtoElemJson for ExtensionNumberResponse {
1441    fn serialize_proto_json<S: ::serde::Serializer>(
1442        v: &Self,
1443        s: S,
1444    ) -> ::core::result::Result<S::Ok, S::Error> {
1445        ::serde::Serialize::serialize(v, s)
1446    }
1447    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1448        d: D,
1449    ) -> ::core::result::Result<Self, D::Error> {
1450        <Self as ::serde::Deserialize>::deserialize(d)
1451    }
1452}
1453#[doc(hidden)]
1454pub const __EXTENSION_NUMBER_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1455    type_url: "type.googleapis.com/grpc.reflection.v1alpha.ExtensionNumberResponse",
1456    to_json: ::buffa::type_registry::any_to_json::<ExtensionNumberResponse>,
1457    from_json: ::buffa::type_registry::any_from_json::<ExtensionNumberResponse>,
1458    is_wkt: false,
1459};
1460/// A list of ServiceResponse sent by the server answering list_services request.
1461#[derive(Clone, PartialEq, Default)]
1462#[derive(::serde::Serialize, ::serde::Deserialize)]
1463#[serde(default)]
1464pub struct ListServiceResponse {
1465    /// The information of each service may be expanded in the future, so we use
1466    /// ServiceResponse message to encapsulate it.
1467    ///
1468    /// Field 1: `service`
1469    #[serde(
1470        rename = "service",
1471        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_vec",
1472        deserialize_with = "::buffa::json_helpers::null_as_default"
1473    )]
1474    pub service: ::buffa::alloc::vec::Vec<ServiceResponse>,
1475    #[serde(skip)]
1476    #[doc(hidden)]
1477    pub __buffa_unknown_fields: ::buffa::UnknownFields,
1478}
1479impl ::core::fmt::Debug for ListServiceResponse {
1480    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1481        f.debug_struct("ListServiceResponse").field("service", &self.service).finish()
1482    }
1483}
1484impl ListServiceResponse {
1485    /// Protobuf type URL for this message, for use with `Any::pack` and
1486    /// `Any::unpack_if`.
1487    ///
1488    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
1489    pub const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ListServiceResponse";
1490}
1491::buffa::impl_default_instance!(ListServiceResponse);
1492impl ::buffa::MessageName for ListServiceResponse {
1493    const PACKAGE: &'static str = "grpc.reflection.v1alpha";
1494    const NAME: &'static str = "ListServiceResponse";
1495    const FULL_NAME: &'static str = "grpc.reflection.v1alpha.ListServiceResponse";
1496    const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ListServiceResponse";
1497}
1498impl ::buffa::Message for ListServiceResponse {
1499    /// Returns the total encoded size in bytes.
1500    ///
1501    /// The result is a `u32`; the protobuf specification requires all
1502    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
1503    /// compliant message will never overflow this type.
1504    #[allow(clippy::let_and_return)]
1505    fn compute_size(&self, __cache: &mut ::buffa::SizeCache) -> u32 {
1506        #[allow(unused_imports)]
1507        use ::buffa::Enumeration as _;
1508        let mut size = 0u32;
1509        for v in &self.service {
1510            let __slot = __cache.reserve();
1511            let inner_size = v.compute_size(__cache);
1512            __cache.set(__slot, inner_size);
1513            size
1514                += 1u32 + ::buffa::encoding::varint_len(inner_size as u64) as u32
1515                    + inner_size;
1516        }
1517        size += self.__buffa_unknown_fields.encoded_len() as u32;
1518        size
1519    }
1520    fn write_to(
1521        &self,
1522        __cache: &mut ::buffa::SizeCache,
1523        buf: &mut impl ::buffa::bytes::BufMut,
1524    ) {
1525        #[allow(unused_imports)]
1526        use ::buffa::Enumeration as _;
1527        for v in &self.service {
1528            ::buffa::types::put_len_delimited_header(1u32, __cache.consume_next(), buf);
1529            v.write_to(__cache, buf);
1530        }
1531        self.__buffa_unknown_fields.write_to(buf);
1532    }
1533    fn merge_field(
1534        &mut self,
1535        tag: ::buffa::encoding::Tag,
1536        buf: &mut impl ::buffa::bytes::Buf,
1537        ctx: ::buffa::DecodeContext<'_>,
1538    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1539        #[allow(unused_imports)]
1540        use ::buffa::bytes::Buf as _;
1541        #[allow(unused_imports)]
1542        use ::buffa::Enumeration as _;
1543        match tag.field_number() {
1544            1u32 => {
1545                ::buffa::encoding::check_wire_type(
1546                    tag,
1547                    ::buffa::encoding::WireType::LengthDelimited,
1548                )?;
1549                let mut elem = ::core::default::Default::default();
1550                ::buffa::Message::merge_length_delimited(&mut elem, buf, ctx)?;
1551                self.service.push(elem);
1552            }
1553            _ => {
1554                self.__buffa_unknown_fields
1555                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
1556            }
1557        }
1558        ::core::result::Result::Ok(())
1559    }
1560    fn clear(&mut self) {
1561        self.service.clear();
1562        self.__buffa_unknown_fields.clear();
1563    }
1564}
1565impl ::buffa::ExtensionSet for ListServiceResponse {
1566    const PROTO_FQN: &'static str = "grpc.reflection.v1alpha.ListServiceResponse";
1567    fn unknown_fields(&self) -> &::buffa::UnknownFields {
1568        &self.__buffa_unknown_fields
1569    }
1570    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
1571        &mut self.__buffa_unknown_fields
1572    }
1573}
1574impl ::buffa::json_helpers::ProtoElemJson for ListServiceResponse {
1575    fn serialize_proto_json<S: ::serde::Serializer>(
1576        v: &Self,
1577        s: S,
1578    ) -> ::core::result::Result<S::Ok, S::Error> {
1579        ::serde::Serialize::serialize(v, s)
1580    }
1581    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1582        d: D,
1583    ) -> ::core::result::Result<Self, D::Error> {
1584        <Self as ::serde::Deserialize>::deserialize(d)
1585    }
1586}
1587#[doc(hidden)]
1588pub const __LIST_SERVICE_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1589    type_url: "type.googleapis.com/grpc.reflection.v1alpha.ListServiceResponse",
1590    to_json: ::buffa::type_registry::any_to_json::<ListServiceResponse>,
1591    from_json: ::buffa::type_registry::any_from_json::<ListServiceResponse>,
1592    is_wkt: false,
1593};
1594/// The information of a single service used by ListServiceResponse to answer
1595/// list_services request.
1596#[derive(Clone, PartialEq, Default)]
1597#[derive(::serde::Serialize, ::serde::Deserialize)]
1598#[serde(default)]
1599pub struct ServiceResponse {
1600    /// Full name of a registered service, including its package name. The format
1601    /// is \<package\>.\<service\>
1602    ///
1603    /// Field 1: `name`
1604    #[serde(
1605        rename = "name",
1606        with = "::buffa::json_helpers::proto_string",
1607        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
1608    )]
1609    pub name: ::buffa::alloc::string::String,
1610    #[serde(skip)]
1611    #[doc(hidden)]
1612    pub __buffa_unknown_fields: ::buffa::UnknownFields,
1613}
1614impl ::core::fmt::Debug for ServiceResponse {
1615    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1616        f.debug_struct("ServiceResponse").field("name", &self.name).finish()
1617    }
1618}
1619impl ServiceResponse {
1620    /// Protobuf type URL for this message, for use with `Any::pack` and
1621    /// `Any::unpack_if`.
1622    ///
1623    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
1624    pub const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ServiceResponse";
1625}
1626::buffa::impl_default_instance!(ServiceResponse);
1627impl ::buffa::MessageName for ServiceResponse {
1628    const PACKAGE: &'static str = "grpc.reflection.v1alpha";
1629    const NAME: &'static str = "ServiceResponse";
1630    const FULL_NAME: &'static str = "grpc.reflection.v1alpha.ServiceResponse";
1631    const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ServiceResponse";
1632}
1633impl ::buffa::Message for ServiceResponse {
1634    /// Returns the total encoded size in bytes.
1635    ///
1636    /// The result is a `u32`; the protobuf specification requires all
1637    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
1638    /// compliant message will never overflow this type.
1639    #[allow(clippy::let_and_return)]
1640    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
1641        #[allow(unused_imports)]
1642        use ::buffa::Enumeration as _;
1643        let mut size = 0u32;
1644        if !self.name.is_empty() {
1645            size += 1u32 + ::buffa::types::string_encoded_len(&self.name) as u32;
1646        }
1647        size += self.__buffa_unknown_fields.encoded_len() as u32;
1648        size
1649    }
1650    fn write_to(
1651        &self,
1652        _cache: &mut ::buffa::SizeCache,
1653        buf: &mut impl ::buffa::bytes::BufMut,
1654    ) {
1655        #[allow(unused_imports)]
1656        use ::buffa::Enumeration as _;
1657        if !self.name.is_empty() {
1658            ::buffa::types::put_string_field(1u32, &self.name, buf);
1659        }
1660        self.__buffa_unknown_fields.write_to(buf);
1661    }
1662    fn merge_field(
1663        &mut self,
1664        tag: ::buffa::encoding::Tag,
1665        buf: &mut impl ::buffa::bytes::Buf,
1666        ctx: ::buffa::DecodeContext<'_>,
1667    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1668        #[allow(unused_imports)]
1669        use ::buffa::bytes::Buf as _;
1670        #[allow(unused_imports)]
1671        use ::buffa::Enumeration as _;
1672        match tag.field_number() {
1673            1u32 => {
1674                ::buffa::encoding::check_wire_type(
1675                    tag,
1676                    ::buffa::encoding::WireType::LengthDelimited,
1677                )?;
1678                ::buffa::types::merge_string(&mut self.name, buf)?;
1679            }
1680            _ => {
1681                self.__buffa_unknown_fields
1682                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
1683            }
1684        }
1685        ::core::result::Result::Ok(())
1686    }
1687    fn clear(&mut self) {
1688        self.name.clear();
1689        self.__buffa_unknown_fields.clear();
1690    }
1691}
1692impl ::buffa::ExtensionSet for ServiceResponse {
1693    const PROTO_FQN: &'static str = "grpc.reflection.v1alpha.ServiceResponse";
1694    fn unknown_fields(&self) -> &::buffa::UnknownFields {
1695        &self.__buffa_unknown_fields
1696    }
1697    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
1698        &mut self.__buffa_unknown_fields
1699    }
1700}
1701impl ::buffa::json_helpers::ProtoElemJson for ServiceResponse {
1702    fn serialize_proto_json<S: ::serde::Serializer>(
1703        v: &Self,
1704        s: S,
1705    ) -> ::core::result::Result<S::Ok, S::Error> {
1706        ::serde::Serialize::serialize(v, s)
1707    }
1708    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1709        d: D,
1710    ) -> ::core::result::Result<Self, D::Error> {
1711        <Self as ::serde::Deserialize>::deserialize(d)
1712    }
1713}
1714#[doc(hidden)]
1715pub const __SERVICE_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1716    type_url: "type.googleapis.com/grpc.reflection.v1alpha.ServiceResponse",
1717    to_json: ::buffa::type_registry::any_to_json::<ServiceResponse>,
1718    from_json: ::buffa::type_registry::any_from_json::<ServiceResponse>,
1719    is_wkt: false,
1720};
1721/// The error code and error message sent by the server when an error occurs.
1722#[derive(Clone, PartialEq, Default)]
1723#[derive(::serde::Serialize, ::serde::Deserialize)]
1724#[serde(default)]
1725pub struct ErrorResponse {
1726    /// This field uses the error codes defined in grpc::StatusCode.
1727    ///
1728    /// Field 1: `error_code`
1729    #[serde(
1730        rename = "errorCode",
1731        alias = "error_code",
1732        with = "::buffa::json_helpers::int32",
1733        skip_serializing_if = "::buffa::json_helpers::skip_if::is_zero_i32"
1734    )]
1735    pub error_code: i32,
1736    /// Field 2: `error_message`
1737    #[serde(
1738        rename = "errorMessage",
1739        alias = "error_message",
1740        with = "::buffa::json_helpers::proto_string",
1741        skip_serializing_if = "::buffa::json_helpers::skip_if::is_empty_str"
1742    )]
1743    pub error_message: ::buffa::alloc::string::String,
1744    #[serde(skip)]
1745    #[doc(hidden)]
1746    pub __buffa_unknown_fields: ::buffa::UnknownFields,
1747}
1748impl ::core::fmt::Debug for ErrorResponse {
1749    fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1750        f.debug_struct("ErrorResponse")
1751            .field("error_code", &self.error_code)
1752            .field("error_message", &self.error_message)
1753            .finish()
1754    }
1755}
1756impl ErrorResponse {
1757    /// Protobuf type URL for this message, for use with `Any::pack` and
1758    /// `Any::unpack_if`.
1759    ///
1760    /// Format: `type.googleapis.com/<fully.qualified.TypeName>`
1761    pub const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ErrorResponse";
1762}
1763::buffa::impl_default_instance!(ErrorResponse);
1764impl ::buffa::MessageName for ErrorResponse {
1765    const PACKAGE: &'static str = "grpc.reflection.v1alpha";
1766    const NAME: &'static str = "ErrorResponse";
1767    const FULL_NAME: &'static str = "grpc.reflection.v1alpha.ErrorResponse";
1768    const TYPE_URL: &'static str = "type.googleapis.com/grpc.reflection.v1alpha.ErrorResponse";
1769}
1770impl ::buffa::Message for ErrorResponse {
1771    /// Returns the total encoded size in bytes.
1772    ///
1773    /// The result is a `u32`; the protobuf specification requires all
1774    /// messages to fit within 2 GiB (2,147,483,647 bytes), so a
1775    /// compliant message will never overflow this type.
1776    #[allow(clippy::let_and_return)]
1777    fn compute_size(&self, _cache: &mut ::buffa::SizeCache) -> u32 {
1778        #[allow(unused_imports)]
1779        use ::buffa::Enumeration as _;
1780        let mut size = 0u32;
1781        if self.error_code != 0i32 {
1782            size += 1u32 + ::buffa::types::int32_encoded_len(self.error_code) as u32;
1783        }
1784        if !self.error_message.is_empty() {
1785            size
1786                += 1u32 + ::buffa::types::string_encoded_len(&self.error_message) as u32;
1787        }
1788        size += self.__buffa_unknown_fields.encoded_len() as u32;
1789        size
1790    }
1791    fn write_to(
1792        &self,
1793        _cache: &mut ::buffa::SizeCache,
1794        buf: &mut impl ::buffa::bytes::BufMut,
1795    ) {
1796        #[allow(unused_imports)]
1797        use ::buffa::Enumeration as _;
1798        if self.error_code != 0i32 {
1799            ::buffa::types::put_int32_field(1u32, self.error_code, buf);
1800        }
1801        if !self.error_message.is_empty() {
1802            ::buffa::types::put_string_field(2u32, &self.error_message, buf);
1803        }
1804        self.__buffa_unknown_fields.write_to(buf);
1805    }
1806    fn merge_field(
1807        &mut self,
1808        tag: ::buffa::encoding::Tag,
1809        buf: &mut impl ::buffa::bytes::Buf,
1810        ctx: ::buffa::DecodeContext<'_>,
1811    ) -> ::core::result::Result<(), ::buffa::DecodeError> {
1812        #[allow(unused_imports)]
1813        use ::buffa::bytes::Buf as _;
1814        #[allow(unused_imports)]
1815        use ::buffa::Enumeration as _;
1816        match tag.field_number() {
1817            1u32 => {
1818                ::buffa::encoding::check_wire_type(
1819                    tag,
1820                    ::buffa::encoding::WireType::Varint,
1821                )?;
1822                self.error_code = ::buffa::types::decode_int32(buf)?;
1823            }
1824            2u32 => {
1825                ::buffa::encoding::check_wire_type(
1826                    tag,
1827                    ::buffa::encoding::WireType::LengthDelimited,
1828                )?;
1829                ::buffa::types::merge_string(&mut self.error_message, buf)?;
1830            }
1831            _ => {
1832                self.__buffa_unknown_fields
1833                    .push(::buffa::encoding::decode_unknown_field(tag, buf, ctx)?);
1834            }
1835        }
1836        ::core::result::Result::Ok(())
1837    }
1838    fn clear(&mut self) {
1839        self.error_code = 0i32;
1840        self.error_message.clear();
1841        self.__buffa_unknown_fields.clear();
1842    }
1843}
1844impl ::buffa::ExtensionSet for ErrorResponse {
1845    const PROTO_FQN: &'static str = "grpc.reflection.v1alpha.ErrorResponse";
1846    fn unknown_fields(&self) -> &::buffa::UnknownFields {
1847        &self.__buffa_unknown_fields
1848    }
1849    fn unknown_fields_mut(&mut self) -> &mut ::buffa::UnknownFields {
1850        &mut self.__buffa_unknown_fields
1851    }
1852}
1853impl ::buffa::json_helpers::ProtoElemJson for ErrorResponse {
1854    fn serialize_proto_json<S: ::serde::Serializer>(
1855        v: &Self,
1856        s: S,
1857    ) -> ::core::result::Result<S::Ok, S::Error> {
1858        ::serde::Serialize::serialize(v, s)
1859    }
1860    fn deserialize_proto_json<'de, D: ::serde::Deserializer<'de>>(
1861        d: D,
1862    ) -> ::core::result::Result<Self, D::Error> {
1863        <Self as ::serde::Deserialize>::deserialize(d)
1864    }
1865}
1866#[doc(hidden)]
1867pub const __ERROR_RESPONSE_JSON_ANY: ::buffa::type_registry::JsonAnyEntry = ::buffa::type_registry::JsonAnyEntry {
1868    type_url: "type.googleapis.com/grpc.reflection.v1alpha.ErrorResponse",
1869    to_json: ::buffa::type_registry::any_to_json::<ErrorResponse>,
1870    from_json: ::buffa::type_registry::any_from_json::<ErrorResponse>,
1871    is_wkt: false,
1872};