risingwave_pb/
monitor_service.serde.rs

1use crate::monitor_service::*;
2impl serde::Serialize for AnalyzeHeapRequest {
3    #[allow(deprecated)]
4    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5    where
6        S: serde::Serializer,
7    {
8        use serde::ser::SerializeStruct;
9        let mut len = 0;
10        if !self.path.is_empty() {
11            len += 1;
12        }
13        let mut struct_ser = serializer.serialize_struct("monitor_service.AnalyzeHeapRequest", len)?;
14        if !self.path.is_empty() {
15            struct_ser.serialize_field("path", &self.path)?;
16        }
17        struct_ser.end()
18    }
19}
20impl<'de> serde::Deserialize<'de> for AnalyzeHeapRequest {
21    #[allow(deprecated)]
22    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
23    where
24        D: serde::Deserializer<'de>,
25    {
26        const FIELDS: &[&str] = &[
27            "path",
28        ];
29
30        #[allow(clippy::enum_variant_names)]
31        enum GeneratedField {
32            Path,
33        }
34        impl<'de> serde::Deserialize<'de> for GeneratedField {
35            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
36            where
37                D: serde::Deserializer<'de>,
38            {
39                struct GeneratedVisitor;
40
41                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
42                    type Value = GeneratedField;
43
44                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
45                        write!(formatter, "expected one of: {:?}", &FIELDS)
46                    }
47
48                    #[allow(unused_variables)]
49                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
50                    where
51                        E: serde::de::Error,
52                    {
53                        match value {
54                            "path" => Ok(GeneratedField::Path),
55                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
56                        }
57                    }
58                }
59                deserializer.deserialize_identifier(GeneratedVisitor)
60            }
61        }
62        struct GeneratedVisitor;
63        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
64            type Value = AnalyzeHeapRequest;
65
66            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
67                formatter.write_str("struct monitor_service.AnalyzeHeapRequest")
68            }
69
70            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AnalyzeHeapRequest, V::Error>
71                where
72                    V: serde::de::MapAccess<'de>,
73            {
74                let mut path__ = None;
75                while let Some(k) = map_.next_key()? {
76                    match k {
77                        GeneratedField::Path => {
78                            if path__.is_some() {
79                                return Err(serde::de::Error::duplicate_field("path"));
80                            }
81                            path__ = Some(map_.next_value()?);
82                        }
83                    }
84                }
85                Ok(AnalyzeHeapRequest {
86                    path: path__.unwrap_or_default(),
87                })
88            }
89        }
90        deserializer.deserialize_struct("monitor_service.AnalyzeHeapRequest", FIELDS, GeneratedVisitor)
91    }
92}
93impl serde::Serialize for AnalyzeHeapResponse {
94    #[allow(deprecated)]
95    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
96    where
97        S: serde::Serializer,
98    {
99        use serde::ser::SerializeStruct;
100        let mut len = 0;
101        if !self.result.is_empty() {
102            len += 1;
103        }
104        let mut struct_ser = serializer.serialize_struct("monitor_service.AnalyzeHeapResponse", len)?;
105        if !self.result.is_empty() {
106            #[allow(clippy::needless_borrow)]
107            #[allow(clippy::needless_borrows_for_generic_args)]
108            struct_ser.serialize_field("result", pbjson::private::base64::encode(&self.result).as_str())?;
109        }
110        struct_ser.end()
111    }
112}
113impl<'de> serde::Deserialize<'de> for AnalyzeHeapResponse {
114    #[allow(deprecated)]
115    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
116    where
117        D: serde::Deserializer<'de>,
118    {
119        const FIELDS: &[&str] = &[
120            "result",
121        ];
122
123        #[allow(clippy::enum_variant_names)]
124        enum GeneratedField {
125            Result,
126        }
127        impl<'de> serde::Deserialize<'de> for GeneratedField {
128            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
129            where
130                D: serde::Deserializer<'de>,
131            {
132                struct GeneratedVisitor;
133
134                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
135                    type Value = GeneratedField;
136
137                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
138                        write!(formatter, "expected one of: {:?}", &FIELDS)
139                    }
140
141                    #[allow(unused_variables)]
142                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
143                    where
144                        E: serde::de::Error,
145                    {
146                        match value {
147                            "result" => Ok(GeneratedField::Result),
148                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
149                        }
150                    }
151                }
152                deserializer.deserialize_identifier(GeneratedVisitor)
153            }
154        }
155        struct GeneratedVisitor;
156        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
157            type Value = AnalyzeHeapResponse;
158
159            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
160                formatter.write_str("struct monitor_service.AnalyzeHeapResponse")
161            }
162
163            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AnalyzeHeapResponse, V::Error>
164                where
165                    V: serde::de::MapAccess<'de>,
166            {
167                let mut result__ = None;
168                while let Some(k) = map_.next_key()? {
169                    match k {
170                        GeneratedField::Result => {
171                            if result__.is_some() {
172                                return Err(serde::de::Error::duplicate_field("result"));
173                            }
174                            result__ = 
175                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
176                            ;
177                        }
178                    }
179                }
180                Ok(AnalyzeHeapResponse {
181                    result: result__.unwrap_or_default(),
182                })
183            }
184        }
185        deserializer.deserialize_struct("monitor_service.AnalyzeHeapResponse", FIELDS, GeneratedVisitor)
186    }
187}
188impl serde::Serialize for ChannelDeltaStats {
189    #[allow(deprecated)]
190    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
191    where
192        S: serde::Serializer,
193    {
194        use serde::ser::SerializeStruct;
195        let mut len = 0;
196        if self.actor_count != 0 {
197            len += 1;
198        }
199        if self.backpressure_rate != 0. {
200            len += 1;
201        }
202        if self.recv_throughput != 0. {
203            len += 1;
204        }
205        if self.send_throughput != 0. {
206            len += 1;
207        }
208        let mut struct_ser = serializer.serialize_struct("monitor_service.ChannelDeltaStats", len)?;
209        if self.actor_count != 0 {
210            struct_ser.serialize_field("n", &self.actor_count)?;
211        }
212        if self.backpressure_rate != 0. {
213            struct_ser.serialize_field("b", &self.backpressure_rate)?;
214        }
215        if self.recv_throughput != 0. {
216            struct_ser.serialize_field("i", &self.recv_throughput)?;
217        }
218        if self.send_throughput != 0. {
219            struct_ser.serialize_field("o", &self.send_throughput)?;
220        }
221        struct_ser.end()
222    }
223}
224impl<'de> serde::Deserialize<'de> for ChannelDeltaStats {
225    #[allow(deprecated)]
226    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
227    where
228        D: serde::Deserializer<'de>,
229    {
230        const FIELDS: &[&str] = &[
231            "actor_count",
232            "n",
233            "backpressure_rate",
234            "b",
235            "recv_throughput",
236            "i",
237            "send_throughput",
238            "o",
239        ];
240
241        #[allow(clippy::enum_variant_names)]
242        enum GeneratedField {
243            ActorCount,
244            BackpressureRate,
245            RecvThroughput,
246            SendThroughput,
247        }
248        impl<'de> serde::Deserialize<'de> for GeneratedField {
249            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
250            where
251                D: serde::Deserializer<'de>,
252            {
253                struct GeneratedVisitor;
254
255                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
256                    type Value = GeneratedField;
257
258                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
259                        write!(formatter, "expected one of: {:?}", &FIELDS)
260                    }
261
262                    #[allow(unused_variables)]
263                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
264                    where
265                        E: serde::de::Error,
266                    {
267                        match value {
268                            "n" | "actor_count" => Ok(GeneratedField::ActorCount),
269                            "b" | "backpressure_rate" => Ok(GeneratedField::BackpressureRate),
270                            "i" | "recv_throughput" => Ok(GeneratedField::RecvThroughput),
271                            "o" | "send_throughput" => Ok(GeneratedField::SendThroughput),
272                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
273                        }
274                    }
275                }
276                deserializer.deserialize_identifier(GeneratedVisitor)
277            }
278        }
279        struct GeneratedVisitor;
280        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
281            type Value = ChannelDeltaStats;
282
283            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
284                formatter.write_str("struct monitor_service.ChannelDeltaStats")
285            }
286
287            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChannelDeltaStats, V::Error>
288                where
289                    V: serde::de::MapAccess<'de>,
290            {
291                let mut actor_count__ = None;
292                let mut backpressure_rate__ = None;
293                let mut recv_throughput__ = None;
294                let mut send_throughput__ = None;
295                while let Some(k) = map_.next_key()? {
296                    match k {
297                        GeneratedField::ActorCount => {
298                            if actor_count__.is_some() {
299                                return Err(serde::de::Error::duplicate_field("n"));
300                            }
301                            actor_count__ = 
302                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
303                            ;
304                        }
305                        GeneratedField::BackpressureRate => {
306                            if backpressure_rate__.is_some() {
307                                return Err(serde::de::Error::duplicate_field("b"));
308                            }
309                            backpressure_rate__ = 
310                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
311                            ;
312                        }
313                        GeneratedField::RecvThroughput => {
314                            if recv_throughput__.is_some() {
315                                return Err(serde::de::Error::duplicate_field("i"));
316                            }
317                            recv_throughput__ = 
318                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
319                            ;
320                        }
321                        GeneratedField::SendThroughput => {
322                            if send_throughput__.is_some() {
323                                return Err(serde::de::Error::duplicate_field("o"));
324                            }
325                            send_throughput__ = 
326                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
327                            ;
328                        }
329                    }
330                }
331                Ok(ChannelDeltaStats {
332                    actor_count: actor_count__.unwrap_or_default(),
333                    backpressure_rate: backpressure_rate__.unwrap_or_default(),
334                    recv_throughput: recv_throughput__.unwrap_or_default(),
335                    send_throughput: send_throughput__.unwrap_or_default(),
336                })
337            }
338        }
339        deserializer.deserialize_struct("monitor_service.ChannelDeltaStats", FIELDS, GeneratedVisitor)
340    }
341}
342impl serde::Serialize for ChannelStats {
343    #[allow(deprecated)]
344    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
345    where
346        S: serde::Serializer,
347    {
348        use serde::ser::SerializeStruct;
349        let mut len = 0;
350        if self.actor_count != 0 {
351            len += 1;
352        }
353        if self.output_blocking_duration != 0. {
354            len += 1;
355        }
356        if self.recv_row_count != 0 {
357            len += 1;
358        }
359        if self.send_row_count != 0 {
360            len += 1;
361        }
362        let mut struct_ser = serializer.serialize_struct("monitor_service.ChannelStats", len)?;
363        if self.actor_count != 0 {
364            struct_ser.serialize_field("n", &self.actor_count)?;
365        }
366        if self.output_blocking_duration != 0. {
367            struct_ser.serialize_field("b", &self.output_blocking_duration)?;
368        }
369        if self.recv_row_count != 0 {
370            #[allow(clippy::needless_borrow)]
371            #[allow(clippy::needless_borrows_for_generic_args)]
372            struct_ser.serialize_field("i", ToString::to_string(&self.recv_row_count).as_str())?;
373        }
374        if self.send_row_count != 0 {
375            #[allow(clippy::needless_borrow)]
376            #[allow(clippy::needless_borrows_for_generic_args)]
377            struct_ser.serialize_field("o", ToString::to_string(&self.send_row_count).as_str())?;
378        }
379        struct_ser.end()
380    }
381}
382impl<'de> serde::Deserialize<'de> for ChannelStats {
383    #[allow(deprecated)]
384    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
385    where
386        D: serde::Deserializer<'de>,
387    {
388        const FIELDS: &[&str] = &[
389            "actor_count",
390            "n",
391            "output_blocking_duration",
392            "b",
393            "recv_row_count",
394            "i",
395            "send_row_count",
396            "o",
397        ];
398
399        #[allow(clippy::enum_variant_names)]
400        enum GeneratedField {
401            ActorCount,
402            OutputBlockingDuration,
403            RecvRowCount,
404            SendRowCount,
405        }
406        impl<'de> serde::Deserialize<'de> for GeneratedField {
407            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
408            where
409                D: serde::Deserializer<'de>,
410            {
411                struct GeneratedVisitor;
412
413                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
414                    type Value = GeneratedField;
415
416                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
417                        write!(formatter, "expected one of: {:?}", &FIELDS)
418                    }
419
420                    #[allow(unused_variables)]
421                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
422                    where
423                        E: serde::de::Error,
424                    {
425                        match value {
426                            "n" | "actor_count" => Ok(GeneratedField::ActorCount),
427                            "b" | "output_blocking_duration" => Ok(GeneratedField::OutputBlockingDuration),
428                            "i" | "recv_row_count" => Ok(GeneratedField::RecvRowCount),
429                            "o" | "send_row_count" => Ok(GeneratedField::SendRowCount),
430                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
431                        }
432                    }
433                }
434                deserializer.deserialize_identifier(GeneratedVisitor)
435            }
436        }
437        struct GeneratedVisitor;
438        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
439            type Value = ChannelStats;
440
441            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
442                formatter.write_str("struct monitor_service.ChannelStats")
443            }
444
445            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChannelStats, V::Error>
446                where
447                    V: serde::de::MapAccess<'de>,
448            {
449                let mut actor_count__ = None;
450                let mut output_blocking_duration__ = None;
451                let mut recv_row_count__ = None;
452                let mut send_row_count__ = None;
453                while let Some(k) = map_.next_key()? {
454                    match k {
455                        GeneratedField::ActorCount => {
456                            if actor_count__.is_some() {
457                                return Err(serde::de::Error::duplicate_field("n"));
458                            }
459                            actor_count__ = 
460                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
461                            ;
462                        }
463                        GeneratedField::OutputBlockingDuration => {
464                            if output_blocking_duration__.is_some() {
465                                return Err(serde::de::Error::duplicate_field("b"));
466                            }
467                            output_blocking_duration__ = 
468                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
469                            ;
470                        }
471                        GeneratedField::RecvRowCount => {
472                            if recv_row_count__.is_some() {
473                                return Err(serde::de::Error::duplicate_field("i"));
474                            }
475                            recv_row_count__ = 
476                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
477                            ;
478                        }
479                        GeneratedField::SendRowCount => {
480                            if send_row_count__.is_some() {
481                                return Err(serde::de::Error::duplicate_field("o"));
482                            }
483                            send_row_count__ = 
484                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
485                            ;
486                        }
487                    }
488                }
489                Ok(ChannelStats {
490                    actor_count: actor_count__.unwrap_or_default(),
491                    output_blocking_duration: output_blocking_duration__.unwrap_or_default(),
492                    recv_row_count: recv_row_count__.unwrap_or_default(),
493                    send_row_count: send_row_count__.unwrap_or_default(),
494                })
495            }
496        }
497        deserializer.deserialize_struct("monitor_service.ChannelStats", FIELDS, GeneratedVisitor)
498    }
499}
500impl serde::Serialize for FragmentStats {
501    #[allow(deprecated)]
502    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
503    where
504        S: serde::Serializer,
505    {
506        use serde::ser::SerializeStruct;
507        let mut len = 0;
508        if self.actor_count != 0 {
509            len += 1;
510        }
511        if self.current_epoch != 0 {
512            len += 1;
513        }
514        let mut struct_ser = serializer.serialize_struct("monitor_service.FragmentStats", len)?;
515        if self.actor_count != 0 {
516            struct_ser.serialize_field("n", &self.actor_count)?;
517        }
518        if self.current_epoch != 0 {
519            #[allow(clippy::needless_borrow)]
520            #[allow(clippy::needless_borrows_for_generic_args)]
521            struct_ser.serialize_field("e", ToString::to_string(&self.current_epoch).as_str())?;
522        }
523        struct_ser.end()
524    }
525}
526impl<'de> serde::Deserialize<'de> for FragmentStats {
527    #[allow(deprecated)]
528    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
529    where
530        D: serde::Deserializer<'de>,
531    {
532        const FIELDS: &[&str] = &[
533            "actor_count",
534            "n",
535            "current_epoch",
536            "e",
537        ];
538
539        #[allow(clippy::enum_variant_names)]
540        enum GeneratedField {
541            ActorCount,
542            CurrentEpoch,
543        }
544        impl<'de> serde::Deserialize<'de> for GeneratedField {
545            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
546            where
547                D: serde::Deserializer<'de>,
548            {
549                struct GeneratedVisitor;
550
551                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
552                    type Value = GeneratedField;
553
554                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
555                        write!(formatter, "expected one of: {:?}", &FIELDS)
556                    }
557
558                    #[allow(unused_variables)]
559                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
560                    where
561                        E: serde::de::Error,
562                    {
563                        match value {
564                            "n" | "actor_count" => Ok(GeneratedField::ActorCount),
565                            "e" | "current_epoch" => Ok(GeneratedField::CurrentEpoch),
566                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
567                        }
568                    }
569                }
570                deserializer.deserialize_identifier(GeneratedVisitor)
571            }
572        }
573        struct GeneratedVisitor;
574        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
575            type Value = FragmentStats;
576
577            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
578                formatter.write_str("struct monitor_service.FragmentStats")
579            }
580
581            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentStats, V::Error>
582                where
583                    V: serde::de::MapAccess<'de>,
584            {
585                let mut actor_count__ = None;
586                let mut current_epoch__ = None;
587                while let Some(k) = map_.next_key()? {
588                    match k {
589                        GeneratedField::ActorCount => {
590                            if actor_count__.is_some() {
591                                return Err(serde::de::Error::duplicate_field("n"));
592                            }
593                            actor_count__ = 
594                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
595                            ;
596                        }
597                        GeneratedField::CurrentEpoch => {
598                            if current_epoch__.is_some() {
599                                return Err(serde::de::Error::duplicate_field("e"));
600                            }
601                            current_epoch__ = 
602                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
603                            ;
604                        }
605                    }
606                }
607                Ok(FragmentStats {
608                    actor_count: actor_count__.unwrap_or_default(),
609                    current_epoch: current_epoch__.unwrap_or_default(),
610                })
611            }
612        }
613        deserializer.deserialize_struct("monitor_service.FragmentStats", FIELDS, GeneratedVisitor)
614    }
615}
616impl serde::Serialize for GetProfileStatsRequest {
617    #[allow(deprecated)]
618    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
619    where
620        S: serde::Serializer,
621    {
622        use serde::ser::SerializeStruct;
623        let mut len = 0;
624        if !self.executor_ids.is_empty() {
625            len += 1;
626        }
627        if !self.dispatcher_fragment_ids.is_empty() {
628            len += 1;
629        }
630        let mut struct_ser = serializer.serialize_struct("monitor_service.GetProfileStatsRequest", len)?;
631        if !self.executor_ids.is_empty() {
632            struct_ser.serialize_field("executorIds", &self.executor_ids.iter().map(ToString::to_string).collect::<Vec<_>>())?;
633        }
634        if !self.dispatcher_fragment_ids.is_empty() {
635            struct_ser.serialize_field("dispatcherFragmentIds", &self.dispatcher_fragment_ids)?;
636        }
637        struct_ser.end()
638    }
639}
640impl<'de> serde::Deserialize<'de> for GetProfileStatsRequest {
641    #[allow(deprecated)]
642    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
643    where
644        D: serde::Deserializer<'de>,
645    {
646        const FIELDS: &[&str] = &[
647            "executor_ids",
648            "executorIds",
649            "dispatcher_fragment_ids",
650            "dispatcherFragmentIds",
651        ];
652
653        #[allow(clippy::enum_variant_names)]
654        enum GeneratedField {
655            ExecutorIds,
656            DispatcherFragmentIds,
657        }
658        impl<'de> serde::Deserialize<'de> for GeneratedField {
659            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
660            where
661                D: serde::Deserializer<'de>,
662            {
663                struct GeneratedVisitor;
664
665                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
666                    type Value = GeneratedField;
667
668                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
669                        write!(formatter, "expected one of: {:?}", &FIELDS)
670                    }
671
672                    #[allow(unused_variables)]
673                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
674                    where
675                        E: serde::de::Error,
676                    {
677                        match value {
678                            "executorIds" | "executor_ids" => Ok(GeneratedField::ExecutorIds),
679                            "dispatcherFragmentIds" | "dispatcher_fragment_ids" => Ok(GeneratedField::DispatcherFragmentIds),
680                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
681                        }
682                    }
683                }
684                deserializer.deserialize_identifier(GeneratedVisitor)
685            }
686        }
687        struct GeneratedVisitor;
688        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
689            type Value = GetProfileStatsRequest;
690
691            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
692                formatter.write_str("struct monitor_service.GetProfileStatsRequest")
693            }
694
695            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetProfileStatsRequest, V::Error>
696                where
697                    V: serde::de::MapAccess<'de>,
698            {
699                let mut executor_ids__ = None;
700                let mut dispatcher_fragment_ids__ = None;
701                while let Some(k) = map_.next_key()? {
702                    match k {
703                        GeneratedField::ExecutorIds => {
704                            if executor_ids__.is_some() {
705                                return Err(serde::de::Error::duplicate_field("executorIds"));
706                            }
707                            executor_ids__ = 
708                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
709                                    .into_iter().map(|x| x.0).collect())
710                            ;
711                        }
712                        GeneratedField::DispatcherFragmentIds => {
713                            if dispatcher_fragment_ids__.is_some() {
714                                return Err(serde::de::Error::duplicate_field("dispatcherFragmentIds"));
715                            }
716                            dispatcher_fragment_ids__ = 
717                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
718                                    .into_iter().map(|x| x.0).collect())
719                            ;
720                        }
721                    }
722                }
723                Ok(GetProfileStatsRequest {
724                    executor_ids: executor_ids__.unwrap_or_default(),
725                    dispatcher_fragment_ids: dispatcher_fragment_ids__.unwrap_or_default(),
726                })
727            }
728        }
729        deserializer.deserialize_struct("monitor_service.GetProfileStatsRequest", FIELDS, GeneratedVisitor)
730    }
731}
732impl serde::Serialize for GetProfileStatsResponse {
733    #[allow(deprecated)]
734    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
735    where
736        S: serde::Serializer,
737    {
738        use serde::ser::SerializeStruct;
739        let mut len = 0;
740        if !self.stream_node_output_row_count.is_empty() {
741            len += 1;
742        }
743        if !self.stream_node_output_blocking_duration_ns.is_empty() {
744            len += 1;
745        }
746        if !self.dispatch_fragment_output_row_count.is_empty() {
747            len += 1;
748        }
749        if !self.dispatch_fragment_output_blocking_duration_ns.is_empty() {
750            len += 1;
751        }
752        let mut struct_ser = serializer.serialize_struct("monitor_service.GetProfileStatsResponse", len)?;
753        if !self.stream_node_output_row_count.is_empty() {
754            let v: std::collections::HashMap<_, _> = self.stream_node_output_row_count.iter()
755                .map(|(k, v)| (k, v.to_string())).collect();
756            struct_ser.serialize_field("streamNodeOutputRowCount", &v)?;
757        }
758        if !self.stream_node_output_blocking_duration_ns.is_empty() {
759            let v: std::collections::HashMap<_, _> = self.stream_node_output_blocking_duration_ns.iter()
760                .map(|(k, v)| (k, v.to_string())).collect();
761            struct_ser.serialize_field("streamNodeOutputBlockingDurationNs", &v)?;
762        }
763        if !self.dispatch_fragment_output_row_count.is_empty() {
764            let v: std::collections::HashMap<_, _> = self.dispatch_fragment_output_row_count.iter()
765                .map(|(k, v)| (k, v.to_string())).collect();
766            struct_ser.serialize_field("dispatchFragmentOutputRowCount", &v)?;
767        }
768        if !self.dispatch_fragment_output_blocking_duration_ns.is_empty() {
769            let v: std::collections::HashMap<_, _> = self.dispatch_fragment_output_blocking_duration_ns.iter()
770                .map(|(k, v)| (k, v.to_string())).collect();
771            struct_ser.serialize_field("dispatchFragmentOutputBlockingDurationNs", &v)?;
772        }
773        struct_ser.end()
774    }
775}
776impl<'de> serde::Deserialize<'de> for GetProfileStatsResponse {
777    #[allow(deprecated)]
778    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
779    where
780        D: serde::Deserializer<'de>,
781    {
782        const FIELDS: &[&str] = &[
783            "stream_node_output_row_count",
784            "streamNodeOutputRowCount",
785            "stream_node_output_blocking_duration_ns",
786            "streamNodeOutputBlockingDurationNs",
787            "dispatch_fragment_output_row_count",
788            "dispatchFragmentOutputRowCount",
789            "dispatch_fragment_output_blocking_duration_ns",
790            "dispatchFragmentOutputBlockingDurationNs",
791        ];
792
793        #[allow(clippy::enum_variant_names)]
794        enum GeneratedField {
795            StreamNodeOutputRowCount,
796            StreamNodeOutputBlockingDurationNs,
797            DispatchFragmentOutputRowCount,
798            DispatchFragmentOutputBlockingDurationNs,
799        }
800        impl<'de> serde::Deserialize<'de> for GeneratedField {
801            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
802            where
803                D: serde::Deserializer<'de>,
804            {
805                struct GeneratedVisitor;
806
807                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
808                    type Value = GeneratedField;
809
810                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
811                        write!(formatter, "expected one of: {:?}", &FIELDS)
812                    }
813
814                    #[allow(unused_variables)]
815                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
816                    where
817                        E: serde::de::Error,
818                    {
819                        match value {
820                            "streamNodeOutputRowCount" | "stream_node_output_row_count" => Ok(GeneratedField::StreamNodeOutputRowCount),
821                            "streamNodeOutputBlockingDurationNs" | "stream_node_output_blocking_duration_ns" => Ok(GeneratedField::StreamNodeOutputBlockingDurationNs),
822                            "dispatchFragmentOutputRowCount" | "dispatch_fragment_output_row_count" => Ok(GeneratedField::DispatchFragmentOutputRowCount),
823                            "dispatchFragmentOutputBlockingDurationNs" | "dispatch_fragment_output_blocking_duration_ns" => Ok(GeneratedField::DispatchFragmentOutputBlockingDurationNs),
824                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
825                        }
826                    }
827                }
828                deserializer.deserialize_identifier(GeneratedVisitor)
829            }
830        }
831        struct GeneratedVisitor;
832        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
833            type Value = GetProfileStatsResponse;
834
835            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
836                formatter.write_str("struct monitor_service.GetProfileStatsResponse")
837            }
838
839            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetProfileStatsResponse, V::Error>
840                where
841                    V: serde::de::MapAccess<'de>,
842            {
843                let mut stream_node_output_row_count__ = None;
844                let mut stream_node_output_blocking_duration_ns__ = None;
845                let mut dispatch_fragment_output_row_count__ = None;
846                let mut dispatch_fragment_output_blocking_duration_ns__ = None;
847                while let Some(k) = map_.next_key()? {
848                    match k {
849                        GeneratedField::StreamNodeOutputRowCount => {
850                            if stream_node_output_row_count__.is_some() {
851                                return Err(serde::de::Error::duplicate_field("streamNodeOutputRowCount"));
852                            }
853                            stream_node_output_row_count__ = Some(
854                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
855                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
856                            );
857                        }
858                        GeneratedField::StreamNodeOutputBlockingDurationNs => {
859                            if stream_node_output_blocking_duration_ns__.is_some() {
860                                return Err(serde::de::Error::duplicate_field("streamNodeOutputBlockingDurationNs"));
861                            }
862                            stream_node_output_blocking_duration_ns__ = Some(
863                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
864                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
865                            );
866                        }
867                        GeneratedField::DispatchFragmentOutputRowCount => {
868                            if dispatch_fragment_output_row_count__.is_some() {
869                                return Err(serde::de::Error::duplicate_field("dispatchFragmentOutputRowCount"));
870                            }
871                            dispatch_fragment_output_row_count__ = Some(
872                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u64>>>()?
873                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
874                            );
875                        }
876                        GeneratedField::DispatchFragmentOutputBlockingDurationNs => {
877                            if dispatch_fragment_output_blocking_duration_ns__.is_some() {
878                                return Err(serde::de::Error::duplicate_field("dispatchFragmentOutputBlockingDurationNs"));
879                            }
880                            dispatch_fragment_output_blocking_duration_ns__ = Some(
881                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u64>>>()?
882                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
883                            );
884                        }
885                    }
886                }
887                Ok(GetProfileStatsResponse {
888                    stream_node_output_row_count: stream_node_output_row_count__.unwrap_or_default(),
889                    stream_node_output_blocking_duration_ns: stream_node_output_blocking_duration_ns__.unwrap_or_default(),
890                    dispatch_fragment_output_row_count: dispatch_fragment_output_row_count__.unwrap_or_default(),
891                    dispatch_fragment_output_blocking_duration_ns: dispatch_fragment_output_blocking_duration_ns__.unwrap_or_default(),
892                })
893            }
894        }
895        deserializer.deserialize_struct("monitor_service.GetProfileStatsResponse", FIELDS, GeneratedVisitor)
896    }
897}
898impl serde::Serialize for GetStreamingPrometheusStatsResponse {
899    #[allow(deprecated)]
900    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
901    where
902        S: serde::Serializer,
903    {
904        use serde::ser::SerializeStruct;
905        let mut len = 0;
906        if !self.channel_stats.is_empty() {
907            len += 1;
908        }
909        if !self.fragment_stats.is_empty() {
910            len += 1;
911        }
912        if !self.relation_stats.is_empty() {
913            len += 1;
914        }
915        let mut struct_ser = serializer.serialize_struct("monitor_service.GetStreamingPrometheusStatsResponse", len)?;
916        if !self.channel_stats.is_empty() {
917            struct_ser.serialize_field("channelStats", &self.channel_stats)?;
918        }
919        if !self.fragment_stats.is_empty() {
920            struct_ser.serialize_field("fragmentStats", &self.fragment_stats)?;
921        }
922        if !self.relation_stats.is_empty() {
923            struct_ser.serialize_field("relationStats", &self.relation_stats)?;
924        }
925        struct_ser.end()
926    }
927}
928impl<'de> serde::Deserialize<'de> for GetStreamingPrometheusStatsResponse {
929    #[allow(deprecated)]
930    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
931    where
932        D: serde::Deserializer<'de>,
933    {
934        const FIELDS: &[&str] = &[
935            "channel_stats",
936            "channelStats",
937            "fragment_stats",
938            "fragmentStats",
939            "relation_stats",
940            "relationStats",
941        ];
942
943        #[allow(clippy::enum_variant_names)]
944        enum GeneratedField {
945            ChannelStats,
946            FragmentStats,
947            RelationStats,
948        }
949        impl<'de> serde::Deserialize<'de> for GeneratedField {
950            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
951            where
952                D: serde::Deserializer<'de>,
953            {
954                struct GeneratedVisitor;
955
956                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
957                    type Value = GeneratedField;
958
959                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
960                        write!(formatter, "expected one of: {:?}", &FIELDS)
961                    }
962
963                    #[allow(unused_variables)]
964                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
965                    where
966                        E: serde::de::Error,
967                    {
968                        match value {
969                            "channelStats" | "channel_stats" => Ok(GeneratedField::ChannelStats),
970                            "fragmentStats" | "fragment_stats" => Ok(GeneratedField::FragmentStats),
971                            "relationStats" | "relation_stats" => Ok(GeneratedField::RelationStats),
972                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
973                        }
974                    }
975                }
976                deserializer.deserialize_identifier(GeneratedVisitor)
977            }
978        }
979        struct GeneratedVisitor;
980        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
981            type Value = GetStreamingPrometheusStatsResponse;
982
983            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
984                formatter.write_str("struct monitor_service.GetStreamingPrometheusStatsResponse")
985            }
986
987            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetStreamingPrometheusStatsResponse, V::Error>
988                where
989                    V: serde::de::MapAccess<'de>,
990            {
991                let mut channel_stats__ = None;
992                let mut fragment_stats__ = None;
993                let mut relation_stats__ = None;
994                while let Some(k) = map_.next_key()? {
995                    match k {
996                        GeneratedField::ChannelStats => {
997                            if channel_stats__.is_some() {
998                                return Err(serde::de::Error::duplicate_field("channelStats"));
999                            }
1000                            channel_stats__ = Some(
1001                                map_.next_value::<std::collections::HashMap<_, _>>()?
1002                            );
1003                        }
1004                        GeneratedField::FragmentStats => {
1005                            if fragment_stats__.is_some() {
1006                                return Err(serde::de::Error::duplicate_field("fragmentStats"));
1007                            }
1008                            fragment_stats__ = Some(
1009                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1010                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
1011                            );
1012                        }
1013                        GeneratedField::RelationStats => {
1014                            if relation_stats__.is_some() {
1015                                return Err(serde::de::Error::duplicate_field("relationStats"));
1016                            }
1017                            relation_stats__ = Some(
1018                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1019                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
1020                            );
1021                        }
1022                    }
1023                }
1024                Ok(GetStreamingPrometheusStatsResponse {
1025                    channel_stats: channel_stats__.unwrap_or_default(),
1026                    fragment_stats: fragment_stats__.unwrap_or_default(),
1027                    relation_stats: relation_stats__.unwrap_or_default(),
1028                })
1029            }
1030        }
1031        deserializer.deserialize_struct("monitor_service.GetStreamingPrometheusStatsResponse", FIELDS, GeneratedVisitor)
1032    }
1033}
1034impl serde::Serialize for GetStreamingStatsRequest {
1035    #[allow(deprecated)]
1036    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1037    where
1038        S: serde::Serializer,
1039    {
1040        use serde::ser::SerializeStruct;
1041        let len = 0;
1042        let struct_ser = serializer.serialize_struct("monitor_service.GetStreamingStatsRequest", len)?;
1043        struct_ser.end()
1044    }
1045}
1046impl<'de> serde::Deserialize<'de> for GetStreamingStatsRequest {
1047    #[allow(deprecated)]
1048    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1049    where
1050        D: serde::Deserializer<'de>,
1051    {
1052        const FIELDS: &[&str] = &[
1053        ];
1054
1055        #[allow(clippy::enum_variant_names)]
1056        enum GeneratedField {
1057        }
1058        impl<'de> serde::Deserialize<'de> for GeneratedField {
1059            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1060            where
1061                D: serde::Deserializer<'de>,
1062            {
1063                struct GeneratedVisitor;
1064
1065                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1066                    type Value = GeneratedField;
1067
1068                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1069                        write!(formatter, "expected one of: {:?}", &FIELDS)
1070                    }
1071
1072                    #[allow(unused_variables)]
1073                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1074                    where
1075                        E: serde::de::Error,
1076                    {
1077                            Err(serde::de::Error::unknown_field(value, FIELDS))
1078                    }
1079                }
1080                deserializer.deserialize_identifier(GeneratedVisitor)
1081            }
1082        }
1083        struct GeneratedVisitor;
1084        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1085            type Value = GetStreamingStatsRequest;
1086
1087            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1088                formatter.write_str("struct monitor_service.GetStreamingStatsRequest")
1089            }
1090
1091            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetStreamingStatsRequest, V::Error>
1092                where
1093                    V: serde::de::MapAccess<'de>,
1094            {
1095                while map_.next_key::<GeneratedField>()?.is_some() {
1096                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1097                }
1098                Ok(GetStreamingStatsRequest {
1099                })
1100            }
1101        }
1102        deserializer.deserialize_struct("monitor_service.GetStreamingStatsRequest", FIELDS, GeneratedVisitor)
1103    }
1104}
1105impl serde::Serialize for GetStreamingStatsResponse {
1106    #[allow(deprecated)]
1107    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1108    where
1109        S: serde::Serializer,
1110    {
1111        use serde::ser::SerializeStruct;
1112        let mut len = 0;
1113        if !self.channel_stats.is_empty() {
1114            len += 1;
1115        }
1116        if !self.fragment_stats.is_empty() {
1117            len += 1;
1118        }
1119        if !self.relation_stats.is_empty() {
1120            len += 1;
1121        }
1122        let mut struct_ser = serializer.serialize_struct("monitor_service.GetStreamingStatsResponse", len)?;
1123        if !self.channel_stats.is_empty() {
1124            struct_ser.serialize_field("channelStats", &self.channel_stats)?;
1125        }
1126        if !self.fragment_stats.is_empty() {
1127            struct_ser.serialize_field("fragmentStats", &self.fragment_stats)?;
1128        }
1129        if !self.relation_stats.is_empty() {
1130            struct_ser.serialize_field("relationStats", &self.relation_stats)?;
1131        }
1132        struct_ser.end()
1133    }
1134}
1135impl<'de> serde::Deserialize<'de> for GetStreamingStatsResponse {
1136    #[allow(deprecated)]
1137    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1138    where
1139        D: serde::Deserializer<'de>,
1140    {
1141        const FIELDS: &[&str] = &[
1142            "channel_stats",
1143            "channelStats",
1144            "fragment_stats",
1145            "fragmentStats",
1146            "relation_stats",
1147            "relationStats",
1148        ];
1149
1150        #[allow(clippy::enum_variant_names)]
1151        enum GeneratedField {
1152            ChannelStats,
1153            FragmentStats,
1154            RelationStats,
1155        }
1156        impl<'de> serde::Deserialize<'de> for GeneratedField {
1157            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1158            where
1159                D: serde::Deserializer<'de>,
1160            {
1161                struct GeneratedVisitor;
1162
1163                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1164                    type Value = GeneratedField;
1165
1166                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1167                        write!(formatter, "expected one of: {:?}", &FIELDS)
1168                    }
1169
1170                    #[allow(unused_variables)]
1171                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1172                    where
1173                        E: serde::de::Error,
1174                    {
1175                        match value {
1176                            "channelStats" | "channel_stats" => Ok(GeneratedField::ChannelStats),
1177                            "fragmentStats" | "fragment_stats" => Ok(GeneratedField::FragmentStats),
1178                            "relationStats" | "relation_stats" => Ok(GeneratedField::RelationStats),
1179                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1180                        }
1181                    }
1182                }
1183                deserializer.deserialize_identifier(GeneratedVisitor)
1184            }
1185        }
1186        struct GeneratedVisitor;
1187        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1188            type Value = GetStreamingStatsResponse;
1189
1190            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1191                formatter.write_str("struct monitor_service.GetStreamingStatsResponse")
1192            }
1193
1194            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetStreamingStatsResponse, V::Error>
1195                where
1196                    V: serde::de::MapAccess<'de>,
1197            {
1198                let mut channel_stats__ = None;
1199                let mut fragment_stats__ = None;
1200                let mut relation_stats__ = None;
1201                while let Some(k) = map_.next_key()? {
1202                    match k {
1203                        GeneratedField::ChannelStats => {
1204                            if channel_stats__.is_some() {
1205                                return Err(serde::de::Error::duplicate_field("channelStats"));
1206                            }
1207                            channel_stats__ = Some(
1208                                map_.next_value::<std::collections::HashMap<_, _>>()?
1209                            );
1210                        }
1211                        GeneratedField::FragmentStats => {
1212                            if fragment_stats__.is_some() {
1213                                return Err(serde::de::Error::duplicate_field("fragmentStats"));
1214                            }
1215                            fragment_stats__ = Some(
1216                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1217                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
1218                            );
1219                        }
1220                        GeneratedField::RelationStats => {
1221                            if relation_stats__.is_some() {
1222                                return Err(serde::de::Error::duplicate_field("relationStats"));
1223                            }
1224                            relation_stats__ = Some(
1225                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1226                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
1227                            );
1228                        }
1229                    }
1230                }
1231                Ok(GetStreamingStatsResponse {
1232                    channel_stats: channel_stats__.unwrap_or_default(),
1233                    fragment_stats: fragment_stats__.unwrap_or_default(),
1234                    relation_stats: relation_stats__.unwrap_or_default(),
1235                })
1236            }
1237        }
1238        deserializer.deserialize_struct("monitor_service.GetStreamingStatsResponse", FIELDS, GeneratedVisitor)
1239    }
1240}
1241impl serde::Serialize for HeapProfilingRequest {
1242    #[allow(deprecated)]
1243    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1244    where
1245        S: serde::Serializer,
1246    {
1247        use serde::ser::SerializeStruct;
1248        let mut len = 0;
1249        if !self.dir.is_empty() {
1250            len += 1;
1251        }
1252        let mut struct_ser = serializer.serialize_struct("monitor_service.HeapProfilingRequest", len)?;
1253        if !self.dir.is_empty() {
1254            struct_ser.serialize_field("dir", &self.dir)?;
1255        }
1256        struct_ser.end()
1257    }
1258}
1259impl<'de> serde::Deserialize<'de> for HeapProfilingRequest {
1260    #[allow(deprecated)]
1261    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1262    where
1263        D: serde::Deserializer<'de>,
1264    {
1265        const FIELDS: &[&str] = &[
1266            "dir",
1267        ];
1268
1269        #[allow(clippy::enum_variant_names)]
1270        enum GeneratedField {
1271            Dir,
1272        }
1273        impl<'de> serde::Deserialize<'de> for GeneratedField {
1274            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1275            where
1276                D: serde::Deserializer<'de>,
1277            {
1278                struct GeneratedVisitor;
1279
1280                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1281                    type Value = GeneratedField;
1282
1283                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1284                        write!(formatter, "expected one of: {:?}", &FIELDS)
1285                    }
1286
1287                    #[allow(unused_variables)]
1288                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1289                    where
1290                        E: serde::de::Error,
1291                    {
1292                        match value {
1293                            "dir" => Ok(GeneratedField::Dir),
1294                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1295                        }
1296                    }
1297                }
1298                deserializer.deserialize_identifier(GeneratedVisitor)
1299            }
1300        }
1301        struct GeneratedVisitor;
1302        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1303            type Value = HeapProfilingRequest;
1304
1305            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1306                formatter.write_str("struct monitor_service.HeapProfilingRequest")
1307            }
1308
1309            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeapProfilingRequest, V::Error>
1310                where
1311                    V: serde::de::MapAccess<'de>,
1312            {
1313                let mut dir__ = None;
1314                while let Some(k) = map_.next_key()? {
1315                    match k {
1316                        GeneratedField::Dir => {
1317                            if dir__.is_some() {
1318                                return Err(serde::de::Error::duplicate_field("dir"));
1319                            }
1320                            dir__ = Some(map_.next_value()?);
1321                        }
1322                    }
1323                }
1324                Ok(HeapProfilingRequest {
1325                    dir: dir__.unwrap_or_default(),
1326                })
1327            }
1328        }
1329        deserializer.deserialize_struct("monitor_service.HeapProfilingRequest", FIELDS, GeneratedVisitor)
1330    }
1331}
1332impl serde::Serialize for HeapProfilingResponse {
1333    #[allow(deprecated)]
1334    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1335    where
1336        S: serde::Serializer,
1337    {
1338        use serde::ser::SerializeStruct;
1339        let len = 0;
1340        let struct_ser = serializer.serialize_struct("monitor_service.HeapProfilingResponse", len)?;
1341        struct_ser.end()
1342    }
1343}
1344impl<'de> serde::Deserialize<'de> for HeapProfilingResponse {
1345    #[allow(deprecated)]
1346    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1347    where
1348        D: serde::Deserializer<'de>,
1349    {
1350        const FIELDS: &[&str] = &[
1351        ];
1352
1353        #[allow(clippy::enum_variant_names)]
1354        enum GeneratedField {
1355        }
1356        impl<'de> serde::Deserialize<'de> for GeneratedField {
1357            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1358            where
1359                D: serde::Deserializer<'de>,
1360            {
1361                struct GeneratedVisitor;
1362
1363                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1364                    type Value = GeneratedField;
1365
1366                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1367                        write!(formatter, "expected one of: {:?}", &FIELDS)
1368                    }
1369
1370                    #[allow(unused_variables)]
1371                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1372                    where
1373                        E: serde::de::Error,
1374                    {
1375                            Err(serde::de::Error::unknown_field(value, FIELDS))
1376                    }
1377                }
1378                deserializer.deserialize_identifier(GeneratedVisitor)
1379            }
1380        }
1381        struct GeneratedVisitor;
1382        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1383            type Value = HeapProfilingResponse;
1384
1385            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1386                formatter.write_str("struct monitor_service.HeapProfilingResponse")
1387            }
1388
1389            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeapProfilingResponse, V::Error>
1390                where
1391                    V: serde::de::MapAccess<'de>,
1392            {
1393                while map_.next_key::<GeneratedField>()?.is_some() {
1394                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1395                }
1396                Ok(HeapProfilingResponse {
1397                })
1398            }
1399        }
1400        deserializer.deserialize_struct("monitor_service.HeapProfilingResponse", FIELDS, GeneratedVisitor)
1401    }
1402}
1403impl serde::Serialize for ListHeapProfilingRequest {
1404    #[allow(deprecated)]
1405    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1406    where
1407        S: serde::Serializer,
1408    {
1409        use serde::ser::SerializeStruct;
1410        let len = 0;
1411        let struct_ser = serializer.serialize_struct("monitor_service.ListHeapProfilingRequest", len)?;
1412        struct_ser.end()
1413    }
1414}
1415impl<'de> serde::Deserialize<'de> for ListHeapProfilingRequest {
1416    #[allow(deprecated)]
1417    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1418    where
1419        D: serde::Deserializer<'de>,
1420    {
1421        const FIELDS: &[&str] = &[
1422        ];
1423
1424        #[allow(clippy::enum_variant_names)]
1425        enum GeneratedField {
1426        }
1427        impl<'de> serde::Deserialize<'de> for GeneratedField {
1428            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1429            where
1430                D: serde::Deserializer<'de>,
1431            {
1432                struct GeneratedVisitor;
1433
1434                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1435                    type Value = GeneratedField;
1436
1437                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1438                        write!(formatter, "expected one of: {:?}", &FIELDS)
1439                    }
1440
1441                    #[allow(unused_variables)]
1442                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1443                    where
1444                        E: serde::de::Error,
1445                    {
1446                            Err(serde::de::Error::unknown_field(value, FIELDS))
1447                    }
1448                }
1449                deserializer.deserialize_identifier(GeneratedVisitor)
1450            }
1451        }
1452        struct GeneratedVisitor;
1453        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1454            type Value = ListHeapProfilingRequest;
1455
1456            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1457                formatter.write_str("struct monitor_service.ListHeapProfilingRequest")
1458            }
1459
1460            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHeapProfilingRequest, V::Error>
1461                where
1462                    V: serde::de::MapAccess<'de>,
1463            {
1464                while map_.next_key::<GeneratedField>()?.is_some() {
1465                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1466                }
1467                Ok(ListHeapProfilingRequest {
1468                })
1469            }
1470        }
1471        deserializer.deserialize_struct("monitor_service.ListHeapProfilingRequest", FIELDS, GeneratedVisitor)
1472    }
1473}
1474impl serde::Serialize for ListHeapProfilingResponse {
1475    #[allow(deprecated)]
1476    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1477    where
1478        S: serde::Serializer,
1479    {
1480        use serde::ser::SerializeStruct;
1481        let mut len = 0;
1482        if !self.dir.is_empty() {
1483            len += 1;
1484        }
1485        if !self.name_manually.is_empty() {
1486            len += 1;
1487        }
1488        if !self.name_auto.is_empty() {
1489            len += 1;
1490        }
1491        let mut struct_ser = serializer.serialize_struct("monitor_service.ListHeapProfilingResponse", len)?;
1492        if !self.dir.is_empty() {
1493            struct_ser.serialize_field("dir", &self.dir)?;
1494        }
1495        if !self.name_manually.is_empty() {
1496            struct_ser.serialize_field("nameManually", &self.name_manually)?;
1497        }
1498        if !self.name_auto.is_empty() {
1499            struct_ser.serialize_field("nameAuto", &self.name_auto)?;
1500        }
1501        struct_ser.end()
1502    }
1503}
1504impl<'de> serde::Deserialize<'de> for ListHeapProfilingResponse {
1505    #[allow(deprecated)]
1506    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1507    where
1508        D: serde::Deserializer<'de>,
1509    {
1510        const FIELDS: &[&str] = &[
1511            "dir",
1512            "name_manually",
1513            "nameManually",
1514            "name_auto",
1515            "nameAuto",
1516        ];
1517
1518        #[allow(clippy::enum_variant_names)]
1519        enum GeneratedField {
1520            Dir,
1521            NameManually,
1522            NameAuto,
1523        }
1524        impl<'de> serde::Deserialize<'de> for GeneratedField {
1525            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1526            where
1527                D: serde::Deserializer<'de>,
1528            {
1529                struct GeneratedVisitor;
1530
1531                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1532                    type Value = GeneratedField;
1533
1534                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1535                        write!(formatter, "expected one of: {:?}", &FIELDS)
1536                    }
1537
1538                    #[allow(unused_variables)]
1539                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1540                    where
1541                        E: serde::de::Error,
1542                    {
1543                        match value {
1544                            "dir" => Ok(GeneratedField::Dir),
1545                            "nameManually" | "name_manually" => Ok(GeneratedField::NameManually),
1546                            "nameAuto" | "name_auto" => Ok(GeneratedField::NameAuto),
1547                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1548                        }
1549                    }
1550                }
1551                deserializer.deserialize_identifier(GeneratedVisitor)
1552            }
1553        }
1554        struct GeneratedVisitor;
1555        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1556            type Value = ListHeapProfilingResponse;
1557
1558            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1559                formatter.write_str("struct monitor_service.ListHeapProfilingResponse")
1560            }
1561
1562            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListHeapProfilingResponse, V::Error>
1563                where
1564                    V: serde::de::MapAccess<'de>,
1565            {
1566                let mut dir__ = None;
1567                let mut name_manually__ = None;
1568                let mut name_auto__ = None;
1569                while let Some(k) = map_.next_key()? {
1570                    match k {
1571                        GeneratedField::Dir => {
1572                            if dir__.is_some() {
1573                                return Err(serde::de::Error::duplicate_field("dir"));
1574                            }
1575                            dir__ = Some(map_.next_value()?);
1576                        }
1577                        GeneratedField::NameManually => {
1578                            if name_manually__.is_some() {
1579                                return Err(serde::de::Error::duplicate_field("nameManually"));
1580                            }
1581                            name_manually__ = Some(map_.next_value()?);
1582                        }
1583                        GeneratedField::NameAuto => {
1584                            if name_auto__.is_some() {
1585                                return Err(serde::de::Error::duplicate_field("nameAuto"));
1586                            }
1587                            name_auto__ = Some(map_.next_value()?);
1588                        }
1589                    }
1590                }
1591                Ok(ListHeapProfilingResponse {
1592                    dir: dir__.unwrap_or_default(),
1593                    name_manually: name_manually__.unwrap_or_default(),
1594                    name_auto: name_auto__.unwrap_or_default(),
1595                })
1596            }
1597        }
1598        deserializer.deserialize_struct("monitor_service.ListHeapProfilingResponse", FIELDS, GeneratedVisitor)
1599    }
1600}
1601impl serde::Serialize for ProfilingRequest {
1602    #[allow(deprecated)]
1603    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1604    where
1605        S: serde::Serializer,
1606    {
1607        use serde::ser::SerializeStruct;
1608        let mut len = 0;
1609        if self.sleep_s != 0 {
1610            len += 1;
1611        }
1612        let mut struct_ser = serializer.serialize_struct("monitor_service.ProfilingRequest", len)?;
1613        if self.sleep_s != 0 {
1614            #[allow(clippy::needless_borrow)]
1615            #[allow(clippy::needless_borrows_for_generic_args)]
1616            struct_ser.serialize_field("sleepS", ToString::to_string(&self.sleep_s).as_str())?;
1617        }
1618        struct_ser.end()
1619    }
1620}
1621impl<'de> serde::Deserialize<'de> for ProfilingRequest {
1622    #[allow(deprecated)]
1623    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1624    where
1625        D: serde::Deserializer<'de>,
1626    {
1627        const FIELDS: &[&str] = &[
1628            "sleep_s",
1629            "sleepS",
1630        ];
1631
1632        #[allow(clippy::enum_variant_names)]
1633        enum GeneratedField {
1634            SleepS,
1635        }
1636        impl<'de> serde::Deserialize<'de> for GeneratedField {
1637            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1638            where
1639                D: serde::Deserializer<'de>,
1640            {
1641                struct GeneratedVisitor;
1642
1643                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1644                    type Value = GeneratedField;
1645
1646                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1647                        write!(formatter, "expected one of: {:?}", &FIELDS)
1648                    }
1649
1650                    #[allow(unused_variables)]
1651                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1652                    where
1653                        E: serde::de::Error,
1654                    {
1655                        match value {
1656                            "sleepS" | "sleep_s" => Ok(GeneratedField::SleepS),
1657                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1658                        }
1659                    }
1660                }
1661                deserializer.deserialize_identifier(GeneratedVisitor)
1662            }
1663        }
1664        struct GeneratedVisitor;
1665        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1666            type Value = ProfilingRequest;
1667
1668            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1669                formatter.write_str("struct monitor_service.ProfilingRequest")
1670            }
1671
1672            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProfilingRequest, V::Error>
1673                where
1674                    V: serde::de::MapAccess<'de>,
1675            {
1676                let mut sleep_s__ = None;
1677                while let Some(k) = map_.next_key()? {
1678                    match k {
1679                        GeneratedField::SleepS => {
1680                            if sleep_s__.is_some() {
1681                                return Err(serde::de::Error::duplicate_field("sleepS"));
1682                            }
1683                            sleep_s__ = 
1684                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1685                            ;
1686                        }
1687                    }
1688                }
1689                Ok(ProfilingRequest {
1690                    sleep_s: sleep_s__.unwrap_or_default(),
1691                })
1692            }
1693        }
1694        deserializer.deserialize_struct("monitor_service.ProfilingRequest", FIELDS, GeneratedVisitor)
1695    }
1696}
1697impl serde::Serialize for ProfilingResponse {
1698    #[allow(deprecated)]
1699    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1700    where
1701        S: serde::Serializer,
1702    {
1703        use serde::ser::SerializeStruct;
1704        let mut len = 0;
1705        if !self.result.is_empty() {
1706            len += 1;
1707        }
1708        let mut struct_ser = serializer.serialize_struct("monitor_service.ProfilingResponse", len)?;
1709        if !self.result.is_empty() {
1710            #[allow(clippy::needless_borrow)]
1711            #[allow(clippy::needless_borrows_for_generic_args)]
1712            struct_ser.serialize_field("result", pbjson::private::base64::encode(&self.result).as_str())?;
1713        }
1714        struct_ser.end()
1715    }
1716}
1717impl<'de> serde::Deserialize<'de> for ProfilingResponse {
1718    #[allow(deprecated)]
1719    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1720    where
1721        D: serde::Deserializer<'de>,
1722    {
1723        const FIELDS: &[&str] = &[
1724            "result",
1725        ];
1726
1727        #[allow(clippy::enum_variant_names)]
1728        enum GeneratedField {
1729            Result,
1730        }
1731        impl<'de> serde::Deserialize<'de> for GeneratedField {
1732            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1733            where
1734                D: serde::Deserializer<'de>,
1735            {
1736                struct GeneratedVisitor;
1737
1738                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1739                    type Value = GeneratedField;
1740
1741                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1742                        write!(formatter, "expected one of: {:?}", &FIELDS)
1743                    }
1744
1745                    #[allow(unused_variables)]
1746                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1747                    where
1748                        E: serde::de::Error,
1749                    {
1750                        match value {
1751                            "result" => Ok(GeneratedField::Result),
1752                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1753                        }
1754                    }
1755                }
1756                deserializer.deserialize_identifier(GeneratedVisitor)
1757            }
1758        }
1759        struct GeneratedVisitor;
1760        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1761            type Value = ProfilingResponse;
1762
1763            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1764                formatter.write_str("struct monitor_service.ProfilingResponse")
1765            }
1766
1767            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProfilingResponse, V::Error>
1768                where
1769                    V: serde::de::MapAccess<'de>,
1770            {
1771                let mut result__ = None;
1772                while let Some(k) = map_.next_key()? {
1773                    match k {
1774                        GeneratedField::Result => {
1775                            if result__.is_some() {
1776                                return Err(serde::de::Error::duplicate_field("result"));
1777                            }
1778                            result__ = 
1779                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
1780                            ;
1781                        }
1782                    }
1783                }
1784                Ok(ProfilingResponse {
1785                    result: result__.unwrap_or_default(),
1786                })
1787            }
1788        }
1789        deserializer.deserialize_struct("monitor_service.ProfilingResponse", FIELDS, GeneratedVisitor)
1790    }
1791}
1792impl serde::Serialize for RelationStats {
1793    #[allow(deprecated)]
1794    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1795    where
1796        S: serde::Serializer,
1797    {
1798        use serde::ser::SerializeStruct;
1799        let mut len = 0;
1800        if self.actor_count != 0 {
1801            len += 1;
1802        }
1803        if self.current_epoch != 0 {
1804            len += 1;
1805        }
1806        let mut struct_ser = serializer.serialize_struct("monitor_service.RelationStats", len)?;
1807        if self.actor_count != 0 {
1808            struct_ser.serialize_field("n", &self.actor_count)?;
1809        }
1810        if self.current_epoch != 0 {
1811            #[allow(clippy::needless_borrow)]
1812            #[allow(clippy::needless_borrows_for_generic_args)]
1813            struct_ser.serialize_field("e", ToString::to_string(&self.current_epoch).as_str())?;
1814        }
1815        struct_ser.end()
1816    }
1817}
1818impl<'de> serde::Deserialize<'de> for RelationStats {
1819    #[allow(deprecated)]
1820    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1821    where
1822        D: serde::Deserializer<'de>,
1823    {
1824        const FIELDS: &[&str] = &[
1825            "actor_count",
1826            "n",
1827            "current_epoch",
1828            "e",
1829        ];
1830
1831        #[allow(clippy::enum_variant_names)]
1832        enum GeneratedField {
1833            ActorCount,
1834            CurrentEpoch,
1835        }
1836        impl<'de> serde::Deserialize<'de> for GeneratedField {
1837            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1838            where
1839                D: serde::Deserializer<'de>,
1840            {
1841                struct GeneratedVisitor;
1842
1843                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1844                    type Value = GeneratedField;
1845
1846                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1847                        write!(formatter, "expected one of: {:?}", &FIELDS)
1848                    }
1849
1850                    #[allow(unused_variables)]
1851                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1852                    where
1853                        E: serde::de::Error,
1854                    {
1855                        match value {
1856                            "n" | "actor_count" => Ok(GeneratedField::ActorCount),
1857                            "e" | "current_epoch" => Ok(GeneratedField::CurrentEpoch),
1858                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1859                        }
1860                    }
1861                }
1862                deserializer.deserialize_identifier(GeneratedVisitor)
1863            }
1864        }
1865        struct GeneratedVisitor;
1866        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1867            type Value = RelationStats;
1868
1869            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1870                formatter.write_str("struct monitor_service.RelationStats")
1871            }
1872
1873            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationStats, V::Error>
1874                where
1875                    V: serde::de::MapAccess<'de>,
1876            {
1877                let mut actor_count__ = None;
1878                let mut current_epoch__ = None;
1879                while let Some(k) = map_.next_key()? {
1880                    match k {
1881                        GeneratedField::ActorCount => {
1882                            if actor_count__.is_some() {
1883                                return Err(serde::de::Error::duplicate_field("n"));
1884                            }
1885                            actor_count__ = 
1886                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1887                            ;
1888                        }
1889                        GeneratedField::CurrentEpoch => {
1890                            if current_epoch__.is_some() {
1891                                return Err(serde::de::Error::duplicate_field("e"));
1892                            }
1893                            current_epoch__ = 
1894                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1895                            ;
1896                        }
1897                    }
1898                }
1899                Ok(RelationStats {
1900                    actor_count: actor_count__.unwrap_or_default(),
1901                    current_epoch: current_epoch__.unwrap_or_default(),
1902                })
1903            }
1904        }
1905        deserializer.deserialize_struct("monitor_service.RelationStats", FIELDS, GeneratedVisitor)
1906    }
1907}
1908impl serde::Serialize for StackTraceRequest {
1909    #[allow(deprecated)]
1910    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1911    where
1912        S: serde::Serializer,
1913    {
1914        use serde::ser::SerializeStruct;
1915        let mut len = 0;
1916        if self.actor_traces_format != 0 {
1917            len += 1;
1918        }
1919        let mut struct_ser = serializer.serialize_struct("monitor_service.StackTraceRequest", len)?;
1920        if self.actor_traces_format != 0 {
1921            let v = stack_trace_request::ActorTracesFormat::try_from(self.actor_traces_format)
1922                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.actor_traces_format)))?;
1923            struct_ser.serialize_field("actorTracesFormat", &v)?;
1924        }
1925        struct_ser.end()
1926    }
1927}
1928impl<'de> serde::Deserialize<'de> for StackTraceRequest {
1929    #[allow(deprecated)]
1930    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1931    where
1932        D: serde::Deserializer<'de>,
1933    {
1934        const FIELDS: &[&str] = &[
1935            "actor_traces_format",
1936            "actorTracesFormat",
1937        ];
1938
1939        #[allow(clippy::enum_variant_names)]
1940        enum GeneratedField {
1941            ActorTracesFormat,
1942        }
1943        impl<'de> serde::Deserialize<'de> for GeneratedField {
1944            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1945            where
1946                D: serde::Deserializer<'de>,
1947            {
1948                struct GeneratedVisitor;
1949
1950                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1951                    type Value = GeneratedField;
1952
1953                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1954                        write!(formatter, "expected one of: {:?}", &FIELDS)
1955                    }
1956
1957                    #[allow(unused_variables)]
1958                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1959                    where
1960                        E: serde::de::Error,
1961                    {
1962                        match value {
1963                            "actorTracesFormat" | "actor_traces_format" => Ok(GeneratedField::ActorTracesFormat),
1964                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1965                        }
1966                    }
1967                }
1968                deserializer.deserialize_identifier(GeneratedVisitor)
1969            }
1970        }
1971        struct GeneratedVisitor;
1972        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1973            type Value = StackTraceRequest;
1974
1975            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1976                formatter.write_str("struct monitor_service.StackTraceRequest")
1977            }
1978
1979            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StackTraceRequest, V::Error>
1980                where
1981                    V: serde::de::MapAccess<'de>,
1982            {
1983                let mut actor_traces_format__ = None;
1984                while let Some(k) = map_.next_key()? {
1985                    match k {
1986                        GeneratedField::ActorTracesFormat => {
1987                            if actor_traces_format__.is_some() {
1988                                return Err(serde::de::Error::duplicate_field("actorTracesFormat"));
1989                            }
1990                            actor_traces_format__ = Some(map_.next_value::<stack_trace_request::ActorTracesFormat>()? as i32);
1991                        }
1992                    }
1993                }
1994                Ok(StackTraceRequest {
1995                    actor_traces_format: actor_traces_format__.unwrap_or_default(),
1996                })
1997            }
1998        }
1999        deserializer.deserialize_struct("monitor_service.StackTraceRequest", FIELDS, GeneratedVisitor)
2000    }
2001}
2002impl serde::Serialize for stack_trace_request::ActorTracesFormat {
2003    #[allow(deprecated)]
2004    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2005    where
2006        S: serde::Serializer,
2007    {
2008        let variant = match self {
2009            Self::Unspecified => "UNSPECIFIED",
2010            Self::Json => "JSON",
2011            Self::Text => "TEXT",
2012        };
2013        serializer.serialize_str(variant)
2014    }
2015}
2016impl<'de> serde::Deserialize<'de> for stack_trace_request::ActorTracesFormat {
2017    #[allow(deprecated)]
2018    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2019    where
2020        D: serde::Deserializer<'de>,
2021    {
2022        const FIELDS: &[&str] = &[
2023            "UNSPECIFIED",
2024            "JSON",
2025            "TEXT",
2026        ];
2027
2028        struct GeneratedVisitor;
2029
2030        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2031            type Value = stack_trace_request::ActorTracesFormat;
2032
2033            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2034                write!(formatter, "expected one of: {:?}", &FIELDS)
2035            }
2036
2037            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
2038            where
2039                E: serde::de::Error,
2040            {
2041                i32::try_from(v)
2042                    .ok()
2043                    .and_then(|x| x.try_into().ok())
2044                    .ok_or_else(|| {
2045                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
2046                    })
2047            }
2048
2049            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
2050            where
2051                E: serde::de::Error,
2052            {
2053                i32::try_from(v)
2054                    .ok()
2055                    .and_then(|x| x.try_into().ok())
2056                    .ok_or_else(|| {
2057                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
2058                    })
2059            }
2060
2061            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
2062            where
2063                E: serde::de::Error,
2064            {
2065                match value {
2066                    "UNSPECIFIED" => Ok(stack_trace_request::ActorTracesFormat::Unspecified),
2067                    "JSON" => Ok(stack_trace_request::ActorTracesFormat::Json),
2068                    "TEXT" => Ok(stack_trace_request::ActorTracesFormat::Text),
2069                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
2070                }
2071            }
2072        }
2073        deserializer.deserialize_any(GeneratedVisitor)
2074    }
2075}
2076impl serde::Serialize for StackTraceResponse {
2077    #[allow(deprecated)]
2078    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2079    where
2080        S: serde::Serializer,
2081    {
2082        use serde::ser::SerializeStruct;
2083        let mut len = 0;
2084        if !self.actor_traces.is_empty() {
2085            len += 1;
2086        }
2087        if !self.rpc_traces.is_empty() {
2088            len += 1;
2089        }
2090        if !self.compaction_task_traces.is_empty() {
2091            len += 1;
2092        }
2093        if !self.inflight_barrier_traces.is_empty() {
2094            len += 1;
2095        }
2096        if !self.barrier_worker_state.is_empty() {
2097            len += 1;
2098        }
2099        if !self.jvm_stack_traces.is_empty() {
2100            len += 1;
2101        }
2102        if !self.meta_traces.is_empty() {
2103            len += 1;
2104        }
2105        let mut struct_ser = serializer.serialize_struct("monitor_service.StackTraceResponse", len)?;
2106        if !self.actor_traces.is_empty() {
2107            struct_ser.serialize_field("actorTraces", &self.actor_traces)?;
2108        }
2109        if !self.rpc_traces.is_empty() {
2110            struct_ser.serialize_field("rpcTraces", &self.rpc_traces)?;
2111        }
2112        if !self.compaction_task_traces.is_empty() {
2113            struct_ser.serialize_field("compactionTaskTraces", &self.compaction_task_traces)?;
2114        }
2115        if !self.inflight_barrier_traces.is_empty() {
2116            struct_ser.serialize_field("inflightBarrierTraces", &self.inflight_barrier_traces)?;
2117        }
2118        if !self.barrier_worker_state.is_empty() {
2119            struct_ser.serialize_field("barrierWorkerState", &self.barrier_worker_state)?;
2120        }
2121        if !self.jvm_stack_traces.is_empty() {
2122            struct_ser.serialize_field("jvmStackTraces", &self.jvm_stack_traces)?;
2123        }
2124        if !self.meta_traces.is_empty() {
2125            struct_ser.serialize_field("metaTraces", &self.meta_traces)?;
2126        }
2127        struct_ser.end()
2128    }
2129}
2130impl<'de> serde::Deserialize<'de> for StackTraceResponse {
2131    #[allow(deprecated)]
2132    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2133    where
2134        D: serde::Deserializer<'de>,
2135    {
2136        const FIELDS: &[&str] = &[
2137            "actor_traces",
2138            "actorTraces",
2139            "rpc_traces",
2140            "rpcTraces",
2141            "compaction_task_traces",
2142            "compactionTaskTraces",
2143            "inflight_barrier_traces",
2144            "inflightBarrierTraces",
2145            "barrier_worker_state",
2146            "barrierWorkerState",
2147            "jvm_stack_traces",
2148            "jvmStackTraces",
2149            "meta_traces",
2150            "metaTraces",
2151        ];
2152
2153        #[allow(clippy::enum_variant_names)]
2154        enum GeneratedField {
2155            ActorTraces,
2156            RpcTraces,
2157            CompactionTaskTraces,
2158            InflightBarrierTraces,
2159            BarrierWorkerState,
2160            JvmStackTraces,
2161            MetaTraces,
2162        }
2163        impl<'de> serde::Deserialize<'de> for GeneratedField {
2164            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2165            where
2166                D: serde::Deserializer<'de>,
2167            {
2168                struct GeneratedVisitor;
2169
2170                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2171                    type Value = GeneratedField;
2172
2173                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2174                        write!(formatter, "expected one of: {:?}", &FIELDS)
2175                    }
2176
2177                    #[allow(unused_variables)]
2178                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2179                    where
2180                        E: serde::de::Error,
2181                    {
2182                        match value {
2183                            "actorTraces" | "actor_traces" => Ok(GeneratedField::ActorTraces),
2184                            "rpcTraces" | "rpc_traces" => Ok(GeneratedField::RpcTraces),
2185                            "compactionTaskTraces" | "compaction_task_traces" => Ok(GeneratedField::CompactionTaskTraces),
2186                            "inflightBarrierTraces" | "inflight_barrier_traces" => Ok(GeneratedField::InflightBarrierTraces),
2187                            "barrierWorkerState" | "barrier_worker_state" => Ok(GeneratedField::BarrierWorkerState),
2188                            "jvmStackTraces" | "jvm_stack_traces" => Ok(GeneratedField::JvmStackTraces),
2189                            "metaTraces" | "meta_traces" => Ok(GeneratedField::MetaTraces),
2190                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2191                        }
2192                    }
2193                }
2194                deserializer.deserialize_identifier(GeneratedVisitor)
2195            }
2196        }
2197        struct GeneratedVisitor;
2198        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2199            type Value = StackTraceResponse;
2200
2201            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2202                formatter.write_str("struct monitor_service.StackTraceResponse")
2203            }
2204
2205            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StackTraceResponse, V::Error>
2206                where
2207                    V: serde::de::MapAccess<'de>,
2208            {
2209                let mut actor_traces__ = None;
2210                let mut rpc_traces__ = None;
2211                let mut compaction_task_traces__ = None;
2212                let mut inflight_barrier_traces__ = None;
2213                let mut barrier_worker_state__ = None;
2214                let mut jvm_stack_traces__ = None;
2215                let mut meta_traces__ = None;
2216                while let Some(k) = map_.next_key()? {
2217                    match k {
2218                        GeneratedField::ActorTraces => {
2219                            if actor_traces__.is_some() {
2220                                return Err(serde::de::Error::duplicate_field("actorTraces"));
2221                            }
2222                            actor_traces__ = Some(
2223                                map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2224                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
2225                            );
2226                        }
2227                        GeneratedField::RpcTraces => {
2228                            if rpc_traces__.is_some() {
2229                                return Err(serde::de::Error::duplicate_field("rpcTraces"));
2230                            }
2231                            rpc_traces__ = Some(
2232                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
2233                            );
2234                        }
2235                        GeneratedField::CompactionTaskTraces => {
2236                            if compaction_task_traces__.is_some() {
2237                                return Err(serde::de::Error::duplicate_field("compactionTaskTraces"));
2238                            }
2239                            compaction_task_traces__ = Some(
2240                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
2241                            );
2242                        }
2243                        GeneratedField::InflightBarrierTraces => {
2244                            if inflight_barrier_traces__.is_some() {
2245                                return Err(serde::de::Error::duplicate_field("inflightBarrierTraces"));
2246                            }
2247                            inflight_barrier_traces__ = Some(
2248                                map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u64>, _>>()?
2249                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
2250                            );
2251                        }
2252                        GeneratedField::BarrierWorkerState => {
2253                            if barrier_worker_state__.is_some() {
2254                                return Err(serde::de::Error::duplicate_field("barrierWorkerState"));
2255                            }
2256                            barrier_worker_state__ = Some(
2257                                map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2258                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
2259                            );
2260                        }
2261                        GeneratedField::JvmStackTraces => {
2262                            if jvm_stack_traces__.is_some() {
2263                                return Err(serde::de::Error::duplicate_field("jvmStackTraces"));
2264                            }
2265                            jvm_stack_traces__ = Some(
2266                                map_.next_value::<std::collections::BTreeMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2267                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
2268                            );
2269                        }
2270                        GeneratedField::MetaTraces => {
2271                            if meta_traces__.is_some() {
2272                                return Err(serde::de::Error::duplicate_field("metaTraces"));
2273                            }
2274                            meta_traces__ = Some(
2275                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
2276                            );
2277                        }
2278                    }
2279                }
2280                Ok(StackTraceResponse {
2281                    actor_traces: actor_traces__.unwrap_or_default(),
2282                    rpc_traces: rpc_traces__.unwrap_or_default(),
2283                    compaction_task_traces: compaction_task_traces__.unwrap_or_default(),
2284                    inflight_barrier_traces: inflight_barrier_traces__.unwrap_or_default(),
2285                    barrier_worker_state: barrier_worker_state__.unwrap_or_default(),
2286                    jvm_stack_traces: jvm_stack_traces__.unwrap_or_default(),
2287                    meta_traces: meta_traces__.unwrap_or_default(),
2288                })
2289            }
2290        }
2291        deserializer.deserialize_struct("monitor_service.StackTraceResponse", FIELDS, GeneratedVisitor)
2292    }
2293}
2294impl serde::Serialize for TieredCacheTracingRequest {
2295    #[allow(deprecated)]
2296    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2297    where
2298        S: serde::Serializer,
2299    {
2300        use serde::ser::SerializeStruct;
2301        let mut len = 0;
2302        if self.enable {
2303            len += 1;
2304        }
2305        if self.record_hybrid_insert_threshold_ms.is_some() {
2306            len += 1;
2307        }
2308        if self.record_hybrid_get_threshold_ms.is_some() {
2309            len += 1;
2310        }
2311        if self.record_hybrid_obtain_threshold_ms.is_some() {
2312            len += 1;
2313        }
2314        if self.record_hybrid_remove_threshold_ms.is_some() {
2315            len += 1;
2316        }
2317        if self.record_hybrid_fetch_threshold_ms.is_some() {
2318            len += 1;
2319        }
2320        let mut struct_ser = serializer.serialize_struct("monitor_service.TieredCacheTracingRequest", len)?;
2321        if self.enable {
2322            struct_ser.serialize_field("enable", &self.enable)?;
2323        }
2324        if let Some(v) = self.record_hybrid_insert_threshold_ms.as_ref() {
2325            struct_ser.serialize_field("recordHybridInsertThresholdMs", v)?;
2326        }
2327        if let Some(v) = self.record_hybrid_get_threshold_ms.as_ref() {
2328            struct_ser.serialize_field("recordHybridGetThresholdMs", v)?;
2329        }
2330        if let Some(v) = self.record_hybrid_obtain_threshold_ms.as_ref() {
2331            struct_ser.serialize_field("recordHybridObtainThresholdMs", v)?;
2332        }
2333        if let Some(v) = self.record_hybrid_remove_threshold_ms.as_ref() {
2334            struct_ser.serialize_field("recordHybridRemoveThresholdMs", v)?;
2335        }
2336        if let Some(v) = self.record_hybrid_fetch_threshold_ms.as_ref() {
2337            struct_ser.serialize_field("recordHybridFetchThresholdMs", v)?;
2338        }
2339        struct_ser.end()
2340    }
2341}
2342impl<'de> serde::Deserialize<'de> for TieredCacheTracingRequest {
2343    #[allow(deprecated)]
2344    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2345    where
2346        D: serde::Deserializer<'de>,
2347    {
2348        const FIELDS: &[&str] = &[
2349            "enable",
2350            "record_hybrid_insert_threshold_ms",
2351            "recordHybridInsertThresholdMs",
2352            "record_hybrid_get_threshold_ms",
2353            "recordHybridGetThresholdMs",
2354            "record_hybrid_obtain_threshold_ms",
2355            "recordHybridObtainThresholdMs",
2356            "record_hybrid_remove_threshold_ms",
2357            "recordHybridRemoveThresholdMs",
2358            "record_hybrid_fetch_threshold_ms",
2359            "recordHybridFetchThresholdMs",
2360        ];
2361
2362        #[allow(clippy::enum_variant_names)]
2363        enum GeneratedField {
2364            Enable,
2365            RecordHybridInsertThresholdMs,
2366            RecordHybridGetThresholdMs,
2367            RecordHybridObtainThresholdMs,
2368            RecordHybridRemoveThresholdMs,
2369            RecordHybridFetchThresholdMs,
2370        }
2371        impl<'de> serde::Deserialize<'de> for GeneratedField {
2372            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2373            where
2374                D: serde::Deserializer<'de>,
2375            {
2376                struct GeneratedVisitor;
2377
2378                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2379                    type Value = GeneratedField;
2380
2381                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2382                        write!(formatter, "expected one of: {:?}", &FIELDS)
2383                    }
2384
2385                    #[allow(unused_variables)]
2386                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2387                    where
2388                        E: serde::de::Error,
2389                    {
2390                        match value {
2391                            "enable" => Ok(GeneratedField::Enable),
2392                            "recordHybridInsertThresholdMs" | "record_hybrid_insert_threshold_ms" => Ok(GeneratedField::RecordHybridInsertThresholdMs),
2393                            "recordHybridGetThresholdMs" | "record_hybrid_get_threshold_ms" => Ok(GeneratedField::RecordHybridGetThresholdMs),
2394                            "recordHybridObtainThresholdMs" | "record_hybrid_obtain_threshold_ms" => Ok(GeneratedField::RecordHybridObtainThresholdMs),
2395                            "recordHybridRemoveThresholdMs" | "record_hybrid_remove_threshold_ms" => Ok(GeneratedField::RecordHybridRemoveThresholdMs),
2396                            "recordHybridFetchThresholdMs" | "record_hybrid_fetch_threshold_ms" => Ok(GeneratedField::RecordHybridFetchThresholdMs),
2397                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2398                        }
2399                    }
2400                }
2401                deserializer.deserialize_identifier(GeneratedVisitor)
2402            }
2403        }
2404        struct GeneratedVisitor;
2405        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2406            type Value = TieredCacheTracingRequest;
2407
2408            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2409                formatter.write_str("struct monitor_service.TieredCacheTracingRequest")
2410            }
2411
2412            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TieredCacheTracingRequest, V::Error>
2413                where
2414                    V: serde::de::MapAccess<'de>,
2415            {
2416                let mut enable__ = None;
2417                let mut record_hybrid_insert_threshold_ms__ = None;
2418                let mut record_hybrid_get_threshold_ms__ = None;
2419                let mut record_hybrid_obtain_threshold_ms__ = None;
2420                let mut record_hybrid_remove_threshold_ms__ = None;
2421                let mut record_hybrid_fetch_threshold_ms__ = None;
2422                while let Some(k) = map_.next_key()? {
2423                    match k {
2424                        GeneratedField::Enable => {
2425                            if enable__.is_some() {
2426                                return Err(serde::de::Error::duplicate_field("enable"));
2427                            }
2428                            enable__ = Some(map_.next_value()?);
2429                        }
2430                        GeneratedField::RecordHybridInsertThresholdMs => {
2431                            if record_hybrid_insert_threshold_ms__.is_some() {
2432                                return Err(serde::de::Error::duplicate_field("recordHybridInsertThresholdMs"));
2433                            }
2434                            record_hybrid_insert_threshold_ms__ = 
2435                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2436                            ;
2437                        }
2438                        GeneratedField::RecordHybridGetThresholdMs => {
2439                            if record_hybrid_get_threshold_ms__.is_some() {
2440                                return Err(serde::de::Error::duplicate_field("recordHybridGetThresholdMs"));
2441                            }
2442                            record_hybrid_get_threshold_ms__ = 
2443                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2444                            ;
2445                        }
2446                        GeneratedField::RecordHybridObtainThresholdMs => {
2447                            if record_hybrid_obtain_threshold_ms__.is_some() {
2448                                return Err(serde::de::Error::duplicate_field("recordHybridObtainThresholdMs"));
2449                            }
2450                            record_hybrid_obtain_threshold_ms__ = 
2451                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2452                            ;
2453                        }
2454                        GeneratedField::RecordHybridRemoveThresholdMs => {
2455                            if record_hybrid_remove_threshold_ms__.is_some() {
2456                                return Err(serde::de::Error::duplicate_field("recordHybridRemoveThresholdMs"));
2457                            }
2458                            record_hybrid_remove_threshold_ms__ = 
2459                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2460                            ;
2461                        }
2462                        GeneratedField::RecordHybridFetchThresholdMs => {
2463                            if record_hybrid_fetch_threshold_ms__.is_some() {
2464                                return Err(serde::de::Error::duplicate_field("recordHybridFetchThresholdMs"));
2465                            }
2466                            record_hybrid_fetch_threshold_ms__ = 
2467                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2468                            ;
2469                        }
2470                    }
2471                }
2472                Ok(TieredCacheTracingRequest {
2473                    enable: enable__.unwrap_or_default(),
2474                    record_hybrid_insert_threshold_ms: record_hybrid_insert_threshold_ms__,
2475                    record_hybrid_get_threshold_ms: record_hybrid_get_threshold_ms__,
2476                    record_hybrid_obtain_threshold_ms: record_hybrid_obtain_threshold_ms__,
2477                    record_hybrid_remove_threshold_ms: record_hybrid_remove_threshold_ms__,
2478                    record_hybrid_fetch_threshold_ms: record_hybrid_fetch_threshold_ms__,
2479                })
2480            }
2481        }
2482        deserializer.deserialize_struct("monitor_service.TieredCacheTracingRequest", FIELDS, GeneratedVisitor)
2483    }
2484}
2485impl serde::Serialize for TieredCacheTracingResponse {
2486    #[allow(deprecated)]
2487    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2488    where
2489        S: serde::Serializer,
2490    {
2491        use serde::ser::SerializeStruct;
2492        let len = 0;
2493        let struct_ser = serializer.serialize_struct("monitor_service.TieredCacheTracingResponse", len)?;
2494        struct_ser.end()
2495    }
2496}
2497impl<'de> serde::Deserialize<'de> for TieredCacheTracingResponse {
2498    #[allow(deprecated)]
2499    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2500    where
2501        D: serde::Deserializer<'de>,
2502    {
2503        const FIELDS: &[&str] = &[
2504        ];
2505
2506        #[allow(clippy::enum_variant_names)]
2507        enum GeneratedField {
2508        }
2509        impl<'de> serde::Deserialize<'de> for GeneratedField {
2510            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2511            where
2512                D: serde::Deserializer<'de>,
2513            {
2514                struct GeneratedVisitor;
2515
2516                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2517                    type Value = GeneratedField;
2518
2519                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2520                        write!(formatter, "expected one of: {:?}", &FIELDS)
2521                    }
2522
2523                    #[allow(unused_variables)]
2524                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2525                    where
2526                        E: serde::de::Error,
2527                    {
2528                            Err(serde::de::Error::unknown_field(value, FIELDS))
2529                    }
2530                }
2531                deserializer.deserialize_identifier(GeneratedVisitor)
2532            }
2533        }
2534        struct GeneratedVisitor;
2535        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2536            type Value = TieredCacheTracingResponse;
2537
2538            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2539                formatter.write_str("struct monitor_service.TieredCacheTracingResponse")
2540            }
2541
2542            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TieredCacheTracingResponse, V::Error>
2543                where
2544                    V: serde::de::MapAccess<'de>,
2545            {
2546                while map_.next_key::<GeneratedField>()?.is_some() {
2547                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2548                }
2549                Ok(TieredCacheTracingResponse {
2550                })
2551            }
2552        }
2553        deserializer.deserialize_struct("monitor_service.TieredCacheTracingResponse", FIELDS, GeneratedVisitor)
2554    }
2555}