risingwave_pb/
meta.serde.rs

1use crate::meta::*;
2impl serde::Serialize for ActivateWorkerNodeRequest {
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.host.is_some() {
11            len += 1;
12        }
13        if self.node_id != 0 {
14            len += 1;
15        }
16        let mut struct_ser = serializer.serialize_struct("meta.ActivateWorkerNodeRequest", len)?;
17        if let Some(v) = self.host.as_ref() {
18            struct_ser.serialize_field("host", v)?;
19        }
20        if self.node_id != 0 {
21            struct_ser.serialize_field("nodeId", &self.node_id)?;
22        }
23        struct_ser.end()
24    }
25}
26impl<'de> serde::Deserialize<'de> for ActivateWorkerNodeRequest {
27    #[allow(deprecated)]
28    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
29    where
30        D: serde::Deserializer<'de>,
31    {
32        const FIELDS: &[&str] = &[
33            "host",
34            "node_id",
35            "nodeId",
36        ];
37
38        #[allow(clippy::enum_variant_names)]
39        enum GeneratedField {
40            Host,
41            NodeId,
42        }
43        impl<'de> serde::Deserialize<'de> for GeneratedField {
44            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
45            where
46                D: serde::Deserializer<'de>,
47            {
48                struct GeneratedVisitor;
49
50                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
51                    type Value = GeneratedField;
52
53                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
54                        write!(formatter, "expected one of: {:?}", &FIELDS)
55                    }
56
57                    #[allow(unused_variables)]
58                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
59                    where
60                        E: serde::de::Error,
61                    {
62                        match value {
63                            "host" => Ok(GeneratedField::Host),
64                            "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
65                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
66                        }
67                    }
68                }
69                deserializer.deserialize_identifier(GeneratedVisitor)
70            }
71        }
72        struct GeneratedVisitor;
73        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
74            type Value = ActivateWorkerNodeRequest;
75
76            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
77                formatter.write_str("struct meta.ActivateWorkerNodeRequest")
78            }
79
80            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActivateWorkerNodeRequest, V::Error>
81                where
82                    V: serde::de::MapAccess<'de>,
83            {
84                let mut host__ = None;
85                let mut node_id__ = None;
86                while let Some(k) = map_.next_key()? {
87                    match k {
88                        GeneratedField::Host => {
89                            if host__.is_some() {
90                                return Err(serde::de::Error::duplicate_field("host"));
91                            }
92                            host__ = map_.next_value()?;
93                        }
94                        GeneratedField::NodeId => {
95                            if node_id__.is_some() {
96                                return Err(serde::de::Error::duplicate_field("nodeId"));
97                            }
98                            node_id__ = 
99                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
100                            ;
101                        }
102                    }
103                }
104                Ok(ActivateWorkerNodeRequest {
105                    host: host__,
106                    node_id: node_id__.unwrap_or_default(),
107                })
108            }
109        }
110        deserializer.deserialize_struct("meta.ActivateWorkerNodeRequest", FIELDS, GeneratedVisitor)
111    }
112}
113impl serde::Serialize for ActivateWorkerNodeResponse {
114    #[allow(deprecated)]
115    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
116    where
117        S: serde::Serializer,
118    {
119        use serde::ser::SerializeStruct;
120        let mut len = 0;
121        if self.status.is_some() {
122            len += 1;
123        }
124        let mut struct_ser = serializer.serialize_struct("meta.ActivateWorkerNodeResponse", len)?;
125        if let Some(v) = self.status.as_ref() {
126            struct_ser.serialize_field("status", v)?;
127        }
128        struct_ser.end()
129    }
130}
131impl<'de> serde::Deserialize<'de> for ActivateWorkerNodeResponse {
132    #[allow(deprecated)]
133    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
134    where
135        D: serde::Deserializer<'de>,
136    {
137        const FIELDS: &[&str] = &[
138            "status",
139        ];
140
141        #[allow(clippy::enum_variant_names)]
142        enum GeneratedField {
143            Status,
144        }
145        impl<'de> serde::Deserialize<'de> for GeneratedField {
146            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
147            where
148                D: serde::Deserializer<'de>,
149            {
150                struct GeneratedVisitor;
151
152                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
153                    type Value = GeneratedField;
154
155                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
156                        write!(formatter, "expected one of: {:?}", &FIELDS)
157                    }
158
159                    #[allow(unused_variables)]
160                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
161                    where
162                        E: serde::de::Error,
163                    {
164                        match value {
165                            "status" => Ok(GeneratedField::Status),
166                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
167                        }
168                    }
169                }
170                deserializer.deserialize_identifier(GeneratedVisitor)
171            }
172        }
173        struct GeneratedVisitor;
174        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
175            type Value = ActivateWorkerNodeResponse;
176
177            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
178                formatter.write_str("struct meta.ActivateWorkerNodeResponse")
179            }
180
181            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActivateWorkerNodeResponse, V::Error>
182                where
183                    V: serde::de::MapAccess<'de>,
184            {
185                let mut status__ = None;
186                while let Some(k) = map_.next_key()? {
187                    match k {
188                        GeneratedField::Status => {
189                            if status__.is_some() {
190                                return Err(serde::de::Error::duplicate_field("status"));
191                            }
192                            status__ = map_.next_value()?;
193                        }
194                    }
195                }
196                Ok(ActivateWorkerNodeResponse {
197                    status: status__,
198                })
199            }
200        }
201        deserializer.deserialize_struct("meta.ActivateWorkerNodeResponse", FIELDS, GeneratedVisitor)
202    }
203}
204impl serde::Serialize for ActorCountPerParallelism {
205    #[allow(deprecated)]
206    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
207    where
208        S: serde::Serializer,
209    {
210        use serde::ser::SerializeStruct;
211        let mut len = 0;
212        if !self.worker_id_to_actor_count.is_empty() {
213            len += 1;
214        }
215        if self.hard_limit != 0 {
216            len += 1;
217        }
218        if self.soft_limit != 0 {
219            len += 1;
220        }
221        let mut struct_ser = serializer.serialize_struct("meta.ActorCountPerParallelism", len)?;
222        if !self.worker_id_to_actor_count.is_empty() {
223            struct_ser.serialize_field("workerIdToActorCount", &self.worker_id_to_actor_count)?;
224        }
225        if self.hard_limit != 0 {
226            #[allow(clippy::needless_borrow)]
227            #[allow(clippy::needless_borrows_for_generic_args)]
228            struct_ser.serialize_field("hardLimit", ToString::to_string(&self.hard_limit).as_str())?;
229        }
230        if self.soft_limit != 0 {
231            #[allow(clippy::needless_borrow)]
232            #[allow(clippy::needless_borrows_for_generic_args)]
233            struct_ser.serialize_field("softLimit", ToString::to_string(&self.soft_limit).as_str())?;
234        }
235        struct_ser.end()
236    }
237}
238impl<'de> serde::Deserialize<'de> for ActorCountPerParallelism {
239    #[allow(deprecated)]
240    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
241    where
242        D: serde::Deserializer<'de>,
243    {
244        const FIELDS: &[&str] = &[
245            "worker_id_to_actor_count",
246            "workerIdToActorCount",
247            "hard_limit",
248            "hardLimit",
249            "soft_limit",
250            "softLimit",
251        ];
252
253        #[allow(clippy::enum_variant_names)]
254        enum GeneratedField {
255            WorkerIdToActorCount,
256            HardLimit,
257            SoftLimit,
258        }
259        impl<'de> serde::Deserialize<'de> for GeneratedField {
260            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
261            where
262                D: serde::Deserializer<'de>,
263            {
264                struct GeneratedVisitor;
265
266                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
267                    type Value = GeneratedField;
268
269                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
270                        write!(formatter, "expected one of: {:?}", &FIELDS)
271                    }
272
273                    #[allow(unused_variables)]
274                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
275                    where
276                        E: serde::de::Error,
277                    {
278                        match value {
279                            "workerIdToActorCount" | "worker_id_to_actor_count" => Ok(GeneratedField::WorkerIdToActorCount),
280                            "hardLimit" | "hard_limit" => Ok(GeneratedField::HardLimit),
281                            "softLimit" | "soft_limit" => Ok(GeneratedField::SoftLimit),
282                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
283                        }
284                    }
285                }
286                deserializer.deserialize_identifier(GeneratedVisitor)
287            }
288        }
289        struct GeneratedVisitor;
290        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
291            type Value = ActorCountPerParallelism;
292
293            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
294                formatter.write_str("struct meta.ActorCountPerParallelism")
295            }
296
297            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorCountPerParallelism, V::Error>
298                where
299                    V: serde::de::MapAccess<'de>,
300            {
301                let mut worker_id_to_actor_count__ = None;
302                let mut hard_limit__ = None;
303                let mut soft_limit__ = None;
304                while let Some(k) = map_.next_key()? {
305                    match k {
306                        GeneratedField::WorkerIdToActorCount => {
307                            if worker_id_to_actor_count__.is_some() {
308                                return Err(serde::de::Error::duplicate_field("workerIdToActorCount"));
309                            }
310                            worker_id_to_actor_count__ = Some(
311                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
312                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
313                            );
314                        }
315                        GeneratedField::HardLimit => {
316                            if hard_limit__.is_some() {
317                                return Err(serde::de::Error::duplicate_field("hardLimit"));
318                            }
319                            hard_limit__ = 
320                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
321                            ;
322                        }
323                        GeneratedField::SoftLimit => {
324                            if soft_limit__.is_some() {
325                                return Err(serde::de::Error::duplicate_field("softLimit"));
326                            }
327                            soft_limit__ = 
328                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
329                            ;
330                        }
331                    }
332                }
333                Ok(ActorCountPerParallelism {
334                    worker_id_to_actor_count: worker_id_to_actor_count__.unwrap_or_default(),
335                    hard_limit: hard_limit__.unwrap_or_default(),
336                    soft_limit: soft_limit__.unwrap_or_default(),
337                })
338            }
339        }
340        deserializer.deserialize_struct("meta.ActorCountPerParallelism", FIELDS, GeneratedVisitor)
341    }
342}
343impl serde::Serialize for actor_count_per_parallelism::WorkerActorCount {
344    #[allow(deprecated)]
345    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
346    where
347        S: serde::Serializer,
348    {
349        use serde::ser::SerializeStruct;
350        let mut len = 0;
351        if self.actor_count != 0 {
352            len += 1;
353        }
354        if self.parallelism != 0 {
355            len += 1;
356        }
357        let mut struct_ser = serializer.serialize_struct("meta.ActorCountPerParallelism.WorkerActorCount", len)?;
358        if self.actor_count != 0 {
359            #[allow(clippy::needless_borrow)]
360            #[allow(clippy::needless_borrows_for_generic_args)]
361            struct_ser.serialize_field("actorCount", ToString::to_string(&self.actor_count).as_str())?;
362        }
363        if self.parallelism != 0 {
364            #[allow(clippy::needless_borrow)]
365            #[allow(clippy::needless_borrows_for_generic_args)]
366            struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
367        }
368        struct_ser.end()
369    }
370}
371impl<'de> serde::Deserialize<'de> for actor_count_per_parallelism::WorkerActorCount {
372    #[allow(deprecated)]
373    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
374    where
375        D: serde::Deserializer<'de>,
376    {
377        const FIELDS: &[&str] = &[
378            "actor_count",
379            "actorCount",
380            "parallelism",
381        ];
382
383        #[allow(clippy::enum_variant_names)]
384        enum GeneratedField {
385            ActorCount,
386            Parallelism,
387        }
388        impl<'de> serde::Deserialize<'de> for GeneratedField {
389            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
390            where
391                D: serde::Deserializer<'de>,
392            {
393                struct GeneratedVisitor;
394
395                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
396                    type Value = GeneratedField;
397
398                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
399                        write!(formatter, "expected one of: {:?}", &FIELDS)
400                    }
401
402                    #[allow(unused_variables)]
403                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
404                    where
405                        E: serde::de::Error,
406                    {
407                        match value {
408                            "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
409                            "parallelism" => Ok(GeneratedField::Parallelism),
410                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
411                        }
412                    }
413                }
414                deserializer.deserialize_identifier(GeneratedVisitor)
415            }
416        }
417        struct GeneratedVisitor;
418        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
419            type Value = actor_count_per_parallelism::WorkerActorCount;
420
421            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
422                formatter.write_str("struct meta.ActorCountPerParallelism.WorkerActorCount")
423            }
424
425            fn visit_map<V>(self, mut map_: V) -> std::result::Result<actor_count_per_parallelism::WorkerActorCount, V::Error>
426                where
427                    V: serde::de::MapAccess<'de>,
428            {
429                let mut actor_count__ = None;
430                let mut parallelism__ = None;
431                while let Some(k) = map_.next_key()? {
432                    match k {
433                        GeneratedField::ActorCount => {
434                            if actor_count__.is_some() {
435                                return Err(serde::de::Error::duplicate_field("actorCount"));
436                            }
437                            actor_count__ = 
438                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
439                            ;
440                        }
441                        GeneratedField::Parallelism => {
442                            if parallelism__.is_some() {
443                                return Err(serde::de::Error::duplicate_field("parallelism"));
444                            }
445                            parallelism__ = 
446                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
447                            ;
448                        }
449                    }
450                }
451                Ok(actor_count_per_parallelism::WorkerActorCount {
452                    actor_count: actor_count__.unwrap_or_default(),
453                    parallelism: parallelism__.unwrap_or_default(),
454                })
455            }
456        }
457        deserializer.deserialize_struct("meta.ActorCountPerParallelism.WorkerActorCount", FIELDS, GeneratedVisitor)
458    }
459}
460impl serde::Serialize for ActorIds {
461    #[allow(deprecated)]
462    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
463    where
464        S: serde::Serializer,
465    {
466        use serde::ser::SerializeStruct;
467        let mut len = 0;
468        if !self.ids.is_empty() {
469            len += 1;
470        }
471        let mut struct_ser = serializer.serialize_struct("meta.ActorIds", len)?;
472        if !self.ids.is_empty() {
473            struct_ser.serialize_field("ids", &self.ids)?;
474        }
475        struct_ser.end()
476    }
477}
478impl<'de> serde::Deserialize<'de> for ActorIds {
479    #[allow(deprecated)]
480    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
481    where
482        D: serde::Deserializer<'de>,
483    {
484        const FIELDS: &[&str] = &[
485            "ids",
486        ];
487
488        #[allow(clippy::enum_variant_names)]
489        enum GeneratedField {
490            Ids,
491        }
492        impl<'de> serde::Deserialize<'de> for GeneratedField {
493            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
494            where
495                D: serde::Deserializer<'de>,
496            {
497                struct GeneratedVisitor;
498
499                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
500                    type Value = GeneratedField;
501
502                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
503                        write!(formatter, "expected one of: {:?}", &FIELDS)
504                    }
505
506                    #[allow(unused_variables)]
507                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
508                    where
509                        E: serde::de::Error,
510                    {
511                        match value {
512                            "ids" => Ok(GeneratedField::Ids),
513                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
514                        }
515                    }
516                }
517                deserializer.deserialize_identifier(GeneratedVisitor)
518            }
519        }
520        struct GeneratedVisitor;
521        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
522            type Value = ActorIds;
523
524            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
525                formatter.write_str("struct meta.ActorIds")
526            }
527
528            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorIds, V::Error>
529                where
530                    V: serde::de::MapAccess<'de>,
531            {
532                let mut ids__ = None;
533                while let Some(k) = map_.next_key()? {
534                    match k {
535                        GeneratedField::Ids => {
536                            if ids__.is_some() {
537                                return Err(serde::de::Error::duplicate_field("ids"));
538                            }
539                            ids__ = 
540                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
541                                    .into_iter().map(|x| x.0).collect())
542                            ;
543                        }
544                    }
545                }
546                Ok(ActorIds {
547                    ids: ids__.unwrap_or_default(),
548                })
549            }
550        }
551        deserializer.deserialize_struct("meta.ActorIds", FIELDS, GeneratedVisitor)
552    }
553}
554impl serde::Serialize for ActorLocation {
555    #[allow(deprecated)]
556    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
557    where
558        S: serde::Serializer,
559    {
560        use serde::ser::SerializeStruct;
561        let mut len = 0;
562        if self.node.is_some() {
563            len += 1;
564        }
565        if !self.actors.is_empty() {
566            len += 1;
567        }
568        let mut struct_ser = serializer.serialize_struct("meta.ActorLocation", len)?;
569        if let Some(v) = self.node.as_ref() {
570            struct_ser.serialize_field("node", v)?;
571        }
572        if !self.actors.is_empty() {
573            struct_ser.serialize_field("actors", &self.actors)?;
574        }
575        struct_ser.end()
576    }
577}
578impl<'de> serde::Deserialize<'de> for ActorLocation {
579    #[allow(deprecated)]
580    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
581    where
582        D: serde::Deserializer<'de>,
583    {
584        const FIELDS: &[&str] = &[
585            "node",
586            "actors",
587        ];
588
589        #[allow(clippy::enum_variant_names)]
590        enum GeneratedField {
591            Node,
592            Actors,
593        }
594        impl<'de> serde::Deserialize<'de> for GeneratedField {
595            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
596            where
597                D: serde::Deserializer<'de>,
598            {
599                struct GeneratedVisitor;
600
601                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
602                    type Value = GeneratedField;
603
604                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
605                        write!(formatter, "expected one of: {:?}", &FIELDS)
606                    }
607
608                    #[allow(unused_variables)]
609                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
610                    where
611                        E: serde::de::Error,
612                    {
613                        match value {
614                            "node" => Ok(GeneratedField::Node),
615                            "actors" => Ok(GeneratedField::Actors),
616                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
617                        }
618                    }
619                }
620                deserializer.deserialize_identifier(GeneratedVisitor)
621            }
622        }
623        struct GeneratedVisitor;
624        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
625            type Value = ActorLocation;
626
627            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
628                formatter.write_str("struct meta.ActorLocation")
629            }
630
631            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorLocation, V::Error>
632                where
633                    V: serde::de::MapAccess<'de>,
634            {
635                let mut node__ = None;
636                let mut actors__ = None;
637                while let Some(k) = map_.next_key()? {
638                    match k {
639                        GeneratedField::Node => {
640                            if node__.is_some() {
641                                return Err(serde::de::Error::duplicate_field("node"));
642                            }
643                            node__ = map_.next_value()?;
644                        }
645                        GeneratedField::Actors => {
646                            if actors__.is_some() {
647                                return Err(serde::de::Error::duplicate_field("actors"));
648                            }
649                            actors__ = Some(map_.next_value()?);
650                        }
651                    }
652                }
653                Ok(ActorLocation {
654                    node: node__,
655                    actors: actors__.unwrap_or_default(),
656                })
657            }
658        }
659        deserializer.deserialize_struct("meta.ActorLocation", FIELDS, GeneratedVisitor)
660    }
661}
662impl serde::Serialize for AddEventLogRequest {
663    #[allow(deprecated)]
664    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
665    where
666        S: serde::Serializer,
667    {
668        use serde::ser::SerializeStruct;
669        let mut len = 0;
670        if self.event.is_some() {
671            len += 1;
672        }
673        let mut struct_ser = serializer.serialize_struct("meta.AddEventLogRequest", len)?;
674        if let Some(v) = self.event.as_ref() {
675            match v {
676                add_event_log_request::Event::WorkerNodePanic(v) => {
677                    struct_ser.serialize_field("workerNodePanic", v)?;
678                }
679                add_event_log_request::Event::SinkFail(v) => {
680                    struct_ser.serialize_field("sinkFail", v)?;
681                }
682                add_event_log_request::Event::AutoSchemaChangeFail(v) => {
683                    struct_ser.serialize_field("autoSchemaChangeFail", v)?;
684                }
685            }
686        }
687        struct_ser.end()
688    }
689}
690impl<'de> serde::Deserialize<'de> for AddEventLogRequest {
691    #[allow(deprecated)]
692    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
693    where
694        D: serde::Deserializer<'de>,
695    {
696        const FIELDS: &[&str] = &[
697            "worker_node_panic",
698            "workerNodePanic",
699            "sink_fail",
700            "sinkFail",
701            "auto_schema_change_fail",
702            "autoSchemaChangeFail",
703        ];
704
705        #[allow(clippy::enum_variant_names)]
706        enum GeneratedField {
707            WorkerNodePanic,
708            SinkFail,
709            AutoSchemaChangeFail,
710        }
711        impl<'de> serde::Deserialize<'de> for GeneratedField {
712            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
713            where
714                D: serde::Deserializer<'de>,
715            {
716                struct GeneratedVisitor;
717
718                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
719                    type Value = GeneratedField;
720
721                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
722                        write!(formatter, "expected one of: {:?}", &FIELDS)
723                    }
724
725                    #[allow(unused_variables)]
726                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
727                    where
728                        E: serde::de::Error,
729                    {
730                        match value {
731                            "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
732                            "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
733                            "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
734                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
735                        }
736                    }
737                }
738                deserializer.deserialize_identifier(GeneratedVisitor)
739            }
740        }
741        struct GeneratedVisitor;
742        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
743            type Value = AddEventLogRequest;
744
745            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
746                formatter.write_str("struct meta.AddEventLogRequest")
747            }
748
749            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogRequest, V::Error>
750                where
751                    V: serde::de::MapAccess<'de>,
752            {
753                let mut event__ = None;
754                while let Some(k) = map_.next_key()? {
755                    match k {
756                        GeneratedField::WorkerNodePanic => {
757                            if event__.is_some() {
758                                return Err(serde::de::Error::duplicate_field("workerNodePanic"));
759                            }
760                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::WorkerNodePanic)
761;
762                        }
763                        GeneratedField::SinkFail => {
764                            if event__.is_some() {
765                                return Err(serde::de::Error::duplicate_field("sinkFail"));
766                            }
767                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::SinkFail)
768;
769                        }
770                        GeneratedField::AutoSchemaChangeFail => {
771                            if event__.is_some() {
772                                return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
773                            }
774                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(add_event_log_request::Event::AutoSchemaChangeFail)
775;
776                        }
777                    }
778                }
779                Ok(AddEventLogRequest {
780                    event: event__,
781                })
782            }
783        }
784        deserializer.deserialize_struct("meta.AddEventLogRequest", FIELDS, GeneratedVisitor)
785    }
786}
787impl serde::Serialize for AddEventLogResponse {
788    #[allow(deprecated)]
789    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
790    where
791        S: serde::Serializer,
792    {
793        use serde::ser::SerializeStruct;
794        let len = 0;
795        let struct_ser = serializer.serialize_struct("meta.AddEventLogResponse", len)?;
796        struct_ser.end()
797    }
798}
799impl<'de> serde::Deserialize<'de> for AddEventLogResponse {
800    #[allow(deprecated)]
801    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
802    where
803        D: serde::Deserializer<'de>,
804    {
805        const FIELDS: &[&str] = &[
806        ];
807
808        #[allow(clippy::enum_variant_names)]
809        enum GeneratedField {
810        }
811        impl<'de> serde::Deserialize<'de> for GeneratedField {
812            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
813            where
814                D: serde::Deserializer<'de>,
815            {
816                struct GeneratedVisitor;
817
818                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
819                    type Value = GeneratedField;
820
821                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
822                        write!(formatter, "expected one of: {:?}", &FIELDS)
823                    }
824
825                    #[allow(unused_variables)]
826                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
827                    where
828                        E: serde::de::Error,
829                    {
830                            Err(serde::de::Error::unknown_field(value, FIELDS))
831                    }
832                }
833                deserializer.deserialize_identifier(GeneratedVisitor)
834            }
835        }
836        struct GeneratedVisitor;
837        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
838            type Value = AddEventLogResponse;
839
840            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
841                formatter.write_str("struct meta.AddEventLogResponse")
842            }
843
844            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddEventLogResponse, V::Error>
845                where
846                    V: serde::de::MapAccess<'de>,
847            {
848                while map_.next_key::<GeneratedField>()?.is_some() {
849                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
850                }
851                Ok(AddEventLogResponse {
852                })
853            }
854        }
855        deserializer.deserialize_struct("meta.AddEventLogResponse", FIELDS, GeneratedVisitor)
856    }
857}
858impl serde::Serialize for AddWorkerNodeRequest {
859    #[allow(deprecated)]
860    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
861    where
862        S: serde::Serializer,
863    {
864        use serde::ser::SerializeStruct;
865        let mut len = 0;
866        if self.worker_type != 0 {
867            len += 1;
868        }
869        if self.host.is_some() {
870            len += 1;
871        }
872        if self.resource.is_some() {
873            len += 1;
874        }
875        if self.property.is_some() {
876            len += 1;
877        }
878        let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeRequest", len)?;
879        if self.worker_type != 0 {
880            let v = super::common::WorkerType::try_from(self.worker_type)
881                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
882            struct_ser.serialize_field("workerType", &v)?;
883        }
884        if let Some(v) = self.host.as_ref() {
885            struct_ser.serialize_field("host", v)?;
886        }
887        if let Some(v) = self.resource.as_ref() {
888            struct_ser.serialize_field("resource", v)?;
889        }
890        if let Some(v) = self.property.as_ref() {
891            struct_ser.serialize_field("property", v)?;
892        }
893        struct_ser.end()
894    }
895}
896impl<'de> serde::Deserialize<'de> for AddWorkerNodeRequest {
897    #[allow(deprecated)]
898    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
899    where
900        D: serde::Deserializer<'de>,
901    {
902        const FIELDS: &[&str] = &[
903            "worker_type",
904            "workerType",
905            "host",
906            "resource",
907            "property",
908        ];
909
910        #[allow(clippy::enum_variant_names)]
911        enum GeneratedField {
912            WorkerType,
913            Host,
914            Resource,
915            Property,
916        }
917        impl<'de> serde::Deserialize<'de> for GeneratedField {
918            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
919            where
920                D: serde::Deserializer<'de>,
921            {
922                struct GeneratedVisitor;
923
924                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
925                    type Value = GeneratedField;
926
927                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
928                        write!(formatter, "expected one of: {:?}", &FIELDS)
929                    }
930
931                    #[allow(unused_variables)]
932                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
933                    where
934                        E: serde::de::Error,
935                    {
936                        match value {
937                            "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
938                            "host" => Ok(GeneratedField::Host),
939                            "resource" => Ok(GeneratedField::Resource),
940                            "property" => Ok(GeneratedField::Property),
941                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
942                        }
943                    }
944                }
945                deserializer.deserialize_identifier(GeneratedVisitor)
946            }
947        }
948        struct GeneratedVisitor;
949        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
950            type Value = AddWorkerNodeRequest;
951
952            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
953                formatter.write_str("struct meta.AddWorkerNodeRequest")
954            }
955
956            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeRequest, V::Error>
957                where
958                    V: serde::de::MapAccess<'de>,
959            {
960                let mut worker_type__ = None;
961                let mut host__ = None;
962                let mut resource__ = None;
963                let mut property__ = None;
964                while let Some(k) = map_.next_key()? {
965                    match k {
966                        GeneratedField::WorkerType => {
967                            if worker_type__.is_some() {
968                                return Err(serde::de::Error::duplicate_field("workerType"));
969                            }
970                            worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
971                        }
972                        GeneratedField::Host => {
973                            if host__.is_some() {
974                                return Err(serde::de::Error::duplicate_field("host"));
975                            }
976                            host__ = map_.next_value()?;
977                        }
978                        GeneratedField::Resource => {
979                            if resource__.is_some() {
980                                return Err(serde::de::Error::duplicate_field("resource"));
981                            }
982                            resource__ = map_.next_value()?;
983                        }
984                        GeneratedField::Property => {
985                            if property__.is_some() {
986                                return Err(serde::de::Error::duplicate_field("property"));
987                            }
988                            property__ = map_.next_value()?;
989                        }
990                    }
991                }
992                Ok(AddWorkerNodeRequest {
993                    worker_type: worker_type__.unwrap_or_default(),
994                    host: host__,
995                    resource: resource__,
996                    property: property__,
997                })
998            }
999        }
1000        deserializer.deserialize_struct("meta.AddWorkerNodeRequest", FIELDS, GeneratedVisitor)
1001    }
1002}
1003impl serde::Serialize for AddWorkerNodeResponse {
1004    #[allow(deprecated)]
1005    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1006    where
1007        S: serde::Serializer,
1008    {
1009        use serde::ser::SerializeStruct;
1010        let mut len = 0;
1011        if self.node_id.is_some() {
1012            len += 1;
1013        }
1014        if !self.cluster_id.is_empty() {
1015            len += 1;
1016        }
1017        let mut struct_ser = serializer.serialize_struct("meta.AddWorkerNodeResponse", len)?;
1018        if let Some(v) = self.node_id.as_ref() {
1019            struct_ser.serialize_field("nodeId", v)?;
1020        }
1021        if !self.cluster_id.is_empty() {
1022            struct_ser.serialize_field("clusterId", &self.cluster_id)?;
1023        }
1024        struct_ser.end()
1025    }
1026}
1027impl<'de> serde::Deserialize<'de> for AddWorkerNodeResponse {
1028    #[allow(deprecated)]
1029    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1030    where
1031        D: serde::Deserializer<'de>,
1032    {
1033        const FIELDS: &[&str] = &[
1034            "node_id",
1035            "nodeId",
1036            "cluster_id",
1037            "clusterId",
1038        ];
1039
1040        #[allow(clippy::enum_variant_names)]
1041        enum GeneratedField {
1042            NodeId,
1043            ClusterId,
1044        }
1045        impl<'de> serde::Deserialize<'de> for GeneratedField {
1046            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1047            where
1048                D: serde::Deserializer<'de>,
1049            {
1050                struct GeneratedVisitor;
1051
1052                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1053                    type Value = GeneratedField;
1054
1055                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1056                        write!(formatter, "expected one of: {:?}", &FIELDS)
1057                    }
1058
1059                    #[allow(unused_variables)]
1060                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1061                    where
1062                        E: serde::de::Error,
1063                    {
1064                        match value {
1065                            "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
1066                            "clusterId" | "cluster_id" => Ok(GeneratedField::ClusterId),
1067                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1068                        }
1069                    }
1070                }
1071                deserializer.deserialize_identifier(GeneratedVisitor)
1072            }
1073        }
1074        struct GeneratedVisitor;
1075        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1076            type Value = AddWorkerNodeResponse;
1077
1078            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1079                formatter.write_str("struct meta.AddWorkerNodeResponse")
1080            }
1081
1082            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddWorkerNodeResponse, V::Error>
1083                where
1084                    V: serde::de::MapAccess<'de>,
1085            {
1086                let mut node_id__ = None;
1087                let mut cluster_id__ = None;
1088                while let Some(k) = map_.next_key()? {
1089                    match k {
1090                        GeneratedField::NodeId => {
1091                            if node_id__.is_some() {
1092                                return Err(serde::de::Error::duplicate_field("nodeId"));
1093                            }
1094                            node_id__ = 
1095                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1096                            ;
1097                        }
1098                        GeneratedField::ClusterId => {
1099                            if cluster_id__.is_some() {
1100                                return Err(serde::de::Error::duplicate_field("clusterId"));
1101                            }
1102                            cluster_id__ = Some(map_.next_value()?);
1103                        }
1104                    }
1105                }
1106                Ok(AddWorkerNodeResponse {
1107                    node_id: node_id__,
1108                    cluster_id: cluster_id__.unwrap_or_default(),
1109                })
1110            }
1111        }
1112        deserializer.deserialize_struct("meta.AddWorkerNodeResponse", FIELDS, GeneratedVisitor)
1113    }
1114}
1115impl serde::Serialize for AlterConnectorPropsRequest {
1116    #[allow(deprecated)]
1117    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1118    where
1119        S: serde::Serializer,
1120    {
1121        use serde::ser::SerializeStruct;
1122        let mut len = 0;
1123        if self.object_id != 0 {
1124            len += 1;
1125        }
1126        if !self.changed_props.is_empty() {
1127            len += 1;
1128        }
1129        if !self.changed_secret_refs.is_empty() {
1130            len += 1;
1131        }
1132        if self.connector_conn_ref.is_some() {
1133            len += 1;
1134        }
1135        if self.object_type != 0 {
1136            len += 1;
1137        }
1138        let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest", len)?;
1139        if self.object_id != 0 {
1140            struct_ser.serialize_field("objectId", &self.object_id)?;
1141        }
1142        if !self.changed_props.is_empty() {
1143            struct_ser.serialize_field("changedProps", &self.changed_props)?;
1144        }
1145        if !self.changed_secret_refs.is_empty() {
1146            struct_ser.serialize_field("changedSecretRefs", &self.changed_secret_refs)?;
1147        }
1148        if let Some(v) = self.connector_conn_ref.as_ref() {
1149            struct_ser.serialize_field("connectorConnRef", v)?;
1150        }
1151        if self.object_type != 0 {
1152            let v = alter_connector_props_request::AlterConnectorPropsObject::try_from(self.object_type)
1153                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
1154            struct_ser.serialize_field("objectType", &v)?;
1155        }
1156        struct_ser.end()
1157    }
1158}
1159impl<'de> serde::Deserialize<'de> for AlterConnectorPropsRequest {
1160    #[allow(deprecated)]
1161    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1162    where
1163        D: serde::Deserializer<'de>,
1164    {
1165        const FIELDS: &[&str] = &[
1166            "object_id",
1167            "objectId",
1168            "changed_props",
1169            "changedProps",
1170            "changed_secret_refs",
1171            "changedSecretRefs",
1172            "connector_conn_ref",
1173            "connectorConnRef",
1174            "object_type",
1175            "objectType",
1176        ];
1177
1178        #[allow(clippy::enum_variant_names)]
1179        enum GeneratedField {
1180            ObjectId,
1181            ChangedProps,
1182            ChangedSecretRefs,
1183            ConnectorConnRef,
1184            ObjectType,
1185        }
1186        impl<'de> serde::Deserialize<'de> for GeneratedField {
1187            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1188            where
1189                D: serde::Deserializer<'de>,
1190            {
1191                struct GeneratedVisitor;
1192
1193                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1194                    type Value = GeneratedField;
1195
1196                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1197                        write!(formatter, "expected one of: {:?}", &FIELDS)
1198                    }
1199
1200                    #[allow(unused_variables)]
1201                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1202                    where
1203                        E: serde::de::Error,
1204                    {
1205                        match value {
1206                            "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
1207                            "changedProps" | "changed_props" => Ok(GeneratedField::ChangedProps),
1208                            "changedSecretRefs" | "changed_secret_refs" => Ok(GeneratedField::ChangedSecretRefs),
1209                            "connectorConnRef" | "connector_conn_ref" => Ok(GeneratedField::ConnectorConnRef),
1210                            "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
1211                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1212                        }
1213                    }
1214                }
1215                deserializer.deserialize_identifier(GeneratedVisitor)
1216            }
1217        }
1218        struct GeneratedVisitor;
1219        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1220            type Value = AlterConnectorPropsRequest;
1221
1222            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1223                formatter.write_str("struct meta.AlterConnectorPropsRequest")
1224            }
1225
1226            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsRequest, V::Error>
1227                where
1228                    V: serde::de::MapAccess<'de>,
1229            {
1230                let mut object_id__ = None;
1231                let mut changed_props__ = None;
1232                let mut changed_secret_refs__ = None;
1233                let mut connector_conn_ref__ = None;
1234                let mut object_type__ = None;
1235                while let Some(k) = map_.next_key()? {
1236                    match k {
1237                        GeneratedField::ObjectId => {
1238                            if object_id__.is_some() {
1239                                return Err(serde::de::Error::duplicate_field("objectId"));
1240                            }
1241                            object_id__ = 
1242                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1243                            ;
1244                        }
1245                        GeneratedField::ChangedProps => {
1246                            if changed_props__.is_some() {
1247                                return Err(serde::de::Error::duplicate_field("changedProps"));
1248                            }
1249                            changed_props__ = Some(
1250                                map_.next_value::<std::collections::HashMap<_, _>>()?
1251                            );
1252                        }
1253                        GeneratedField::ChangedSecretRefs => {
1254                            if changed_secret_refs__.is_some() {
1255                                return Err(serde::de::Error::duplicate_field("changedSecretRefs"));
1256                            }
1257                            changed_secret_refs__ = Some(
1258                                map_.next_value::<std::collections::HashMap<_, _>>()?
1259                            );
1260                        }
1261                        GeneratedField::ConnectorConnRef => {
1262                            if connector_conn_ref__.is_some() {
1263                                return Err(serde::de::Error::duplicate_field("connectorConnRef"));
1264                            }
1265                            connector_conn_ref__ = 
1266                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1267                            ;
1268                        }
1269                        GeneratedField::ObjectType => {
1270                            if object_type__.is_some() {
1271                                return Err(serde::de::Error::duplicate_field("objectType"));
1272                            }
1273                            object_type__ = Some(map_.next_value::<alter_connector_props_request::AlterConnectorPropsObject>()? as i32);
1274                        }
1275                    }
1276                }
1277                Ok(AlterConnectorPropsRequest {
1278                    object_id: object_id__.unwrap_or_default(),
1279                    changed_props: changed_props__.unwrap_or_default(),
1280                    changed_secret_refs: changed_secret_refs__.unwrap_or_default(),
1281                    connector_conn_ref: connector_conn_ref__,
1282                    object_type: object_type__.unwrap_or_default(),
1283                })
1284            }
1285        }
1286        deserializer.deserialize_struct("meta.AlterConnectorPropsRequest", FIELDS, GeneratedVisitor)
1287    }
1288}
1289impl serde::Serialize for alter_connector_props_request::AlterConnectorPropsObject {
1290    #[allow(deprecated)]
1291    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1292    where
1293        S: serde::Serializer,
1294    {
1295        let variant = match self {
1296            Self::Unspecified => "UNSPECIFIED",
1297            Self::Source => "SOURCE",
1298            Self::Sink => "SINK",
1299            Self::Connection => "CONNECTION",
1300        };
1301        serializer.serialize_str(variant)
1302    }
1303}
1304impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterConnectorPropsObject {
1305    #[allow(deprecated)]
1306    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1307    where
1308        D: serde::Deserializer<'de>,
1309    {
1310        const FIELDS: &[&str] = &[
1311            "UNSPECIFIED",
1312            "SOURCE",
1313            "SINK",
1314            "CONNECTION",
1315        ];
1316
1317        struct GeneratedVisitor;
1318
1319        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1320            type Value = alter_connector_props_request::AlterConnectorPropsObject;
1321
1322            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1323                write!(formatter, "expected one of: {:?}", &FIELDS)
1324            }
1325
1326            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1327            where
1328                E: serde::de::Error,
1329            {
1330                i32::try_from(v)
1331                    .ok()
1332                    .and_then(|x| x.try_into().ok())
1333                    .ok_or_else(|| {
1334                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1335                    })
1336            }
1337
1338            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1339            where
1340                E: serde::de::Error,
1341            {
1342                i32::try_from(v)
1343                    .ok()
1344                    .and_then(|x| x.try_into().ok())
1345                    .ok_or_else(|| {
1346                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1347                    })
1348            }
1349
1350            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1351            where
1352                E: serde::de::Error,
1353            {
1354                match value {
1355                    "UNSPECIFIED" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Unspecified),
1356                    "SOURCE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Source),
1357                    "SINK" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Sink),
1358                    "CONNECTION" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Connection),
1359                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1360                }
1361            }
1362        }
1363        deserializer.deserialize_any(GeneratedVisitor)
1364    }
1365}
1366impl serde::Serialize for AlterConnectorPropsResponse {
1367    #[allow(deprecated)]
1368    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1369    where
1370        S: serde::Serializer,
1371    {
1372        use serde::ser::SerializeStruct;
1373        let len = 0;
1374        let struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsResponse", len)?;
1375        struct_ser.end()
1376    }
1377}
1378impl<'de> serde::Deserialize<'de> for AlterConnectorPropsResponse {
1379    #[allow(deprecated)]
1380    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1381    where
1382        D: serde::Deserializer<'de>,
1383    {
1384        const FIELDS: &[&str] = &[
1385        ];
1386
1387        #[allow(clippy::enum_variant_names)]
1388        enum GeneratedField {
1389        }
1390        impl<'de> serde::Deserialize<'de> for GeneratedField {
1391            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1392            where
1393                D: serde::Deserializer<'de>,
1394            {
1395                struct GeneratedVisitor;
1396
1397                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1398                    type Value = GeneratedField;
1399
1400                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1401                        write!(formatter, "expected one of: {:?}", &FIELDS)
1402                    }
1403
1404                    #[allow(unused_variables)]
1405                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1406                    where
1407                        E: serde::de::Error,
1408                    {
1409                            Err(serde::de::Error::unknown_field(value, FIELDS))
1410                    }
1411                }
1412                deserializer.deserialize_identifier(GeneratedVisitor)
1413            }
1414        }
1415        struct GeneratedVisitor;
1416        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1417            type Value = AlterConnectorPropsResponse;
1418
1419            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1420                formatter.write_str("struct meta.AlterConnectorPropsResponse")
1421            }
1422
1423            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsResponse, V::Error>
1424                where
1425                    V: serde::de::MapAccess<'de>,
1426            {
1427                while map_.next_key::<GeneratedField>()?.is_some() {
1428                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1429                }
1430                Ok(AlterConnectorPropsResponse {
1431                })
1432            }
1433        }
1434        deserializer.deserialize_struct("meta.AlterConnectorPropsResponse", FIELDS, GeneratedVisitor)
1435    }
1436}
1437impl serde::Serialize for ApplyThrottleRequest {
1438    #[allow(deprecated)]
1439    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1440    where
1441        S: serde::Serializer,
1442    {
1443        use serde::ser::SerializeStruct;
1444        let mut len = 0;
1445        if self.kind != 0 {
1446            len += 1;
1447        }
1448        if self.id != 0 {
1449            len += 1;
1450        }
1451        if self.rate.is_some() {
1452            len += 1;
1453        }
1454        let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleRequest", len)?;
1455        if self.kind != 0 {
1456            let v = ThrottleTarget::try_from(self.kind)
1457                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1458            struct_ser.serialize_field("kind", &v)?;
1459        }
1460        if self.id != 0 {
1461            struct_ser.serialize_field("id", &self.id)?;
1462        }
1463        if let Some(v) = self.rate.as_ref() {
1464            struct_ser.serialize_field("rate", v)?;
1465        }
1466        struct_ser.end()
1467    }
1468}
1469impl<'de> serde::Deserialize<'de> for ApplyThrottleRequest {
1470    #[allow(deprecated)]
1471    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1472    where
1473        D: serde::Deserializer<'de>,
1474    {
1475        const FIELDS: &[&str] = &[
1476            "kind",
1477            "id",
1478            "rate",
1479        ];
1480
1481        #[allow(clippy::enum_variant_names)]
1482        enum GeneratedField {
1483            Kind,
1484            Id,
1485            Rate,
1486        }
1487        impl<'de> serde::Deserialize<'de> for GeneratedField {
1488            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1489            where
1490                D: serde::Deserializer<'de>,
1491            {
1492                struct GeneratedVisitor;
1493
1494                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1495                    type Value = GeneratedField;
1496
1497                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1498                        write!(formatter, "expected one of: {:?}", &FIELDS)
1499                    }
1500
1501                    #[allow(unused_variables)]
1502                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1503                    where
1504                        E: serde::de::Error,
1505                    {
1506                        match value {
1507                            "kind" => Ok(GeneratedField::Kind),
1508                            "id" => Ok(GeneratedField::Id),
1509                            "rate" => Ok(GeneratedField::Rate),
1510                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1511                        }
1512                    }
1513                }
1514                deserializer.deserialize_identifier(GeneratedVisitor)
1515            }
1516        }
1517        struct GeneratedVisitor;
1518        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1519            type Value = ApplyThrottleRequest;
1520
1521            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1522                formatter.write_str("struct meta.ApplyThrottleRequest")
1523            }
1524
1525            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleRequest, V::Error>
1526                where
1527                    V: serde::de::MapAccess<'de>,
1528            {
1529                let mut kind__ = None;
1530                let mut id__ = None;
1531                let mut rate__ = None;
1532                while let Some(k) = map_.next_key()? {
1533                    match k {
1534                        GeneratedField::Kind => {
1535                            if kind__.is_some() {
1536                                return Err(serde::de::Error::duplicate_field("kind"));
1537                            }
1538                            kind__ = Some(map_.next_value::<ThrottleTarget>()? as i32);
1539                        }
1540                        GeneratedField::Id => {
1541                            if id__.is_some() {
1542                                return Err(serde::de::Error::duplicate_field("id"));
1543                            }
1544                            id__ = 
1545                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1546                            ;
1547                        }
1548                        GeneratedField::Rate => {
1549                            if rate__.is_some() {
1550                                return Err(serde::de::Error::duplicate_field("rate"));
1551                            }
1552                            rate__ = 
1553                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1554                            ;
1555                        }
1556                    }
1557                }
1558                Ok(ApplyThrottleRequest {
1559                    kind: kind__.unwrap_or_default(),
1560                    id: id__.unwrap_or_default(),
1561                    rate: rate__,
1562                })
1563            }
1564        }
1565        deserializer.deserialize_struct("meta.ApplyThrottleRequest", FIELDS, GeneratedVisitor)
1566    }
1567}
1568impl serde::Serialize for ApplyThrottleResponse {
1569    #[allow(deprecated)]
1570    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1571    where
1572        S: serde::Serializer,
1573    {
1574        use serde::ser::SerializeStruct;
1575        let mut len = 0;
1576        if self.status.is_some() {
1577            len += 1;
1578        }
1579        let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleResponse", len)?;
1580        if let Some(v) = self.status.as_ref() {
1581            struct_ser.serialize_field("status", v)?;
1582        }
1583        struct_ser.end()
1584    }
1585}
1586impl<'de> serde::Deserialize<'de> for ApplyThrottleResponse {
1587    #[allow(deprecated)]
1588    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1589    where
1590        D: serde::Deserializer<'de>,
1591    {
1592        const FIELDS: &[&str] = &[
1593            "status",
1594        ];
1595
1596        #[allow(clippy::enum_variant_names)]
1597        enum GeneratedField {
1598            Status,
1599        }
1600        impl<'de> serde::Deserialize<'de> for GeneratedField {
1601            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1602            where
1603                D: serde::Deserializer<'de>,
1604            {
1605                struct GeneratedVisitor;
1606
1607                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1608                    type Value = GeneratedField;
1609
1610                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1611                        write!(formatter, "expected one of: {:?}", &FIELDS)
1612                    }
1613
1614                    #[allow(unused_variables)]
1615                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1616                    where
1617                        E: serde::de::Error,
1618                    {
1619                        match value {
1620                            "status" => Ok(GeneratedField::Status),
1621                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1622                        }
1623                    }
1624                }
1625                deserializer.deserialize_identifier(GeneratedVisitor)
1626            }
1627        }
1628        struct GeneratedVisitor;
1629        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1630            type Value = ApplyThrottleResponse;
1631
1632            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1633                formatter.write_str("struct meta.ApplyThrottleResponse")
1634            }
1635
1636            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleResponse, V::Error>
1637                where
1638                    V: serde::de::MapAccess<'de>,
1639            {
1640                let mut status__ = None;
1641                while let Some(k) = map_.next_key()? {
1642                    match k {
1643                        GeneratedField::Status => {
1644                            if status__.is_some() {
1645                                return Err(serde::de::Error::duplicate_field("status"));
1646                            }
1647                            status__ = map_.next_value()?;
1648                        }
1649                    }
1650                }
1651                Ok(ApplyThrottleResponse {
1652                    status: status__,
1653                })
1654            }
1655        }
1656        deserializer.deserialize_struct("meta.ApplyThrottleResponse", FIELDS, GeneratedVisitor)
1657    }
1658}
1659impl serde::Serialize for CancelCreatingJobsRequest {
1660    #[allow(deprecated)]
1661    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1662    where
1663        S: serde::Serializer,
1664    {
1665        use serde::ser::SerializeStruct;
1666        let mut len = 0;
1667        if self.jobs.is_some() {
1668            len += 1;
1669        }
1670        let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest", len)?;
1671        if let Some(v) = self.jobs.as_ref() {
1672            match v {
1673                cancel_creating_jobs_request::Jobs::Infos(v) => {
1674                    struct_ser.serialize_field("infos", v)?;
1675                }
1676                cancel_creating_jobs_request::Jobs::Ids(v) => {
1677                    struct_ser.serialize_field("ids", v)?;
1678                }
1679            }
1680        }
1681        struct_ser.end()
1682    }
1683}
1684impl<'de> serde::Deserialize<'de> for CancelCreatingJobsRequest {
1685    #[allow(deprecated)]
1686    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1687    where
1688        D: serde::Deserializer<'de>,
1689    {
1690        const FIELDS: &[&str] = &[
1691            "infos",
1692            "ids",
1693        ];
1694
1695        #[allow(clippy::enum_variant_names)]
1696        enum GeneratedField {
1697            Infos,
1698            Ids,
1699        }
1700        impl<'de> serde::Deserialize<'de> for GeneratedField {
1701            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1702            where
1703                D: serde::Deserializer<'de>,
1704            {
1705                struct GeneratedVisitor;
1706
1707                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1708                    type Value = GeneratedField;
1709
1710                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1711                        write!(formatter, "expected one of: {:?}", &FIELDS)
1712                    }
1713
1714                    #[allow(unused_variables)]
1715                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1716                    where
1717                        E: serde::de::Error,
1718                    {
1719                        match value {
1720                            "infos" => Ok(GeneratedField::Infos),
1721                            "ids" => Ok(GeneratedField::Ids),
1722                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1723                        }
1724                    }
1725                }
1726                deserializer.deserialize_identifier(GeneratedVisitor)
1727            }
1728        }
1729        struct GeneratedVisitor;
1730        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1731            type Value = CancelCreatingJobsRequest;
1732
1733            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1734                formatter.write_str("struct meta.CancelCreatingJobsRequest")
1735            }
1736
1737            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsRequest, V::Error>
1738                where
1739                    V: serde::de::MapAccess<'de>,
1740            {
1741                let mut jobs__ = None;
1742                while let Some(k) = map_.next_key()? {
1743                    match k {
1744                        GeneratedField::Infos => {
1745                            if jobs__.is_some() {
1746                                return Err(serde::de::Error::duplicate_field("infos"));
1747                            }
1748                            jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Infos)
1749;
1750                        }
1751                        GeneratedField::Ids => {
1752                            if jobs__.is_some() {
1753                                return Err(serde::de::Error::duplicate_field("ids"));
1754                            }
1755                            jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Ids)
1756;
1757                        }
1758                    }
1759                }
1760                Ok(CancelCreatingJobsRequest {
1761                    jobs: jobs__,
1762                })
1763            }
1764        }
1765        deserializer.deserialize_struct("meta.CancelCreatingJobsRequest", FIELDS, GeneratedVisitor)
1766    }
1767}
1768impl serde::Serialize for cancel_creating_jobs_request::CreatingJobIds {
1769    #[allow(deprecated)]
1770    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1771    where
1772        S: serde::Serializer,
1773    {
1774        use serde::ser::SerializeStruct;
1775        let mut len = 0;
1776        if !self.job_ids.is_empty() {
1777            len += 1;
1778        }
1779        let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", len)?;
1780        if !self.job_ids.is_empty() {
1781            struct_ser.serialize_field("jobIds", &self.job_ids)?;
1782        }
1783        struct_ser.end()
1784    }
1785}
1786impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobIds {
1787    #[allow(deprecated)]
1788    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1789    where
1790        D: serde::Deserializer<'de>,
1791    {
1792        const FIELDS: &[&str] = &[
1793            "job_ids",
1794            "jobIds",
1795        ];
1796
1797        #[allow(clippy::enum_variant_names)]
1798        enum GeneratedField {
1799            JobIds,
1800        }
1801        impl<'de> serde::Deserialize<'de> for GeneratedField {
1802            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1803            where
1804                D: serde::Deserializer<'de>,
1805            {
1806                struct GeneratedVisitor;
1807
1808                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1809                    type Value = GeneratedField;
1810
1811                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1812                        write!(formatter, "expected one of: {:?}", &FIELDS)
1813                    }
1814
1815                    #[allow(unused_variables)]
1816                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1817                    where
1818                        E: serde::de::Error,
1819                    {
1820                        match value {
1821                            "jobIds" | "job_ids" => Ok(GeneratedField::JobIds),
1822                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1823                        }
1824                    }
1825                }
1826                deserializer.deserialize_identifier(GeneratedVisitor)
1827            }
1828        }
1829        struct GeneratedVisitor;
1830        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1831            type Value = cancel_creating_jobs_request::CreatingJobIds;
1832
1833            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1834                formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobIds")
1835            }
1836
1837            fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobIds, V::Error>
1838                where
1839                    V: serde::de::MapAccess<'de>,
1840            {
1841                let mut job_ids__ = None;
1842                while let Some(k) = map_.next_key()? {
1843                    match k {
1844                        GeneratedField::JobIds => {
1845                            if job_ids__.is_some() {
1846                                return Err(serde::de::Error::duplicate_field("jobIds"));
1847                            }
1848                            job_ids__ = 
1849                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1850                                    .into_iter().map(|x| x.0).collect())
1851                            ;
1852                        }
1853                    }
1854                }
1855                Ok(cancel_creating_jobs_request::CreatingJobIds {
1856                    job_ids: job_ids__.unwrap_or_default(),
1857                })
1858            }
1859        }
1860        deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", FIELDS, GeneratedVisitor)
1861    }
1862}
1863impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfo {
1864    #[allow(deprecated)]
1865    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1866    where
1867        S: serde::Serializer,
1868    {
1869        use serde::ser::SerializeStruct;
1870        let mut len = 0;
1871        if self.database_id != 0 {
1872            len += 1;
1873        }
1874        if self.schema_id != 0 {
1875            len += 1;
1876        }
1877        if !self.name.is_empty() {
1878            len += 1;
1879        }
1880        let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", len)?;
1881        if self.database_id != 0 {
1882            struct_ser.serialize_field("databaseId", &self.database_id)?;
1883        }
1884        if self.schema_id != 0 {
1885            struct_ser.serialize_field("schemaId", &self.schema_id)?;
1886        }
1887        if !self.name.is_empty() {
1888            struct_ser.serialize_field("name", &self.name)?;
1889        }
1890        struct_ser.end()
1891    }
1892}
1893impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfo {
1894    #[allow(deprecated)]
1895    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1896    where
1897        D: serde::Deserializer<'de>,
1898    {
1899        const FIELDS: &[&str] = &[
1900            "database_id",
1901            "databaseId",
1902            "schema_id",
1903            "schemaId",
1904            "name",
1905        ];
1906
1907        #[allow(clippy::enum_variant_names)]
1908        enum GeneratedField {
1909            DatabaseId,
1910            SchemaId,
1911            Name,
1912        }
1913        impl<'de> serde::Deserialize<'de> for GeneratedField {
1914            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1915            where
1916                D: serde::Deserializer<'de>,
1917            {
1918                struct GeneratedVisitor;
1919
1920                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1921                    type Value = GeneratedField;
1922
1923                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1924                        write!(formatter, "expected one of: {:?}", &FIELDS)
1925                    }
1926
1927                    #[allow(unused_variables)]
1928                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1929                    where
1930                        E: serde::de::Error,
1931                    {
1932                        match value {
1933                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
1934                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
1935                            "name" => Ok(GeneratedField::Name),
1936                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1937                        }
1938                    }
1939                }
1940                deserializer.deserialize_identifier(GeneratedVisitor)
1941            }
1942        }
1943        struct GeneratedVisitor;
1944        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1945            type Value = cancel_creating_jobs_request::CreatingJobInfo;
1946
1947            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1948                formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfo")
1949            }
1950
1951            fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfo, V::Error>
1952                where
1953                    V: serde::de::MapAccess<'de>,
1954            {
1955                let mut database_id__ = None;
1956                let mut schema_id__ = None;
1957                let mut name__ = None;
1958                while let Some(k) = map_.next_key()? {
1959                    match k {
1960                        GeneratedField::DatabaseId => {
1961                            if database_id__.is_some() {
1962                                return Err(serde::de::Error::duplicate_field("databaseId"));
1963                            }
1964                            database_id__ = 
1965                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1966                            ;
1967                        }
1968                        GeneratedField::SchemaId => {
1969                            if schema_id__.is_some() {
1970                                return Err(serde::de::Error::duplicate_field("schemaId"));
1971                            }
1972                            schema_id__ = 
1973                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1974                            ;
1975                        }
1976                        GeneratedField::Name => {
1977                            if name__.is_some() {
1978                                return Err(serde::de::Error::duplicate_field("name"));
1979                            }
1980                            name__ = Some(map_.next_value()?);
1981                        }
1982                    }
1983                }
1984                Ok(cancel_creating_jobs_request::CreatingJobInfo {
1985                    database_id: database_id__.unwrap_or_default(),
1986                    schema_id: schema_id__.unwrap_or_default(),
1987                    name: name__.unwrap_or_default(),
1988                })
1989            }
1990        }
1991        deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", FIELDS, GeneratedVisitor)
1992    }
1993}
1994impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfos {
1995    #[allow(deprecated)]
1996    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1997    where
1998        S: serde::Serializer,
1999    {
2000        use serde::ser::SerializeStruct;
2001        let mut len = 0;
2002        if !self.infos.is_empty() {
2003            len += 1;
2004        }
2005        let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", len)?;
2006        if !self.infos.is_empty() {
2007            struct_ser.serialize_field("infos", &self.infos)?;
2008        }
2009        struct_ser.end()
2010    }
2011}
2012impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfos {
2013    #[allow(deprecated)]
2014    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2015    where
2016        D: serde::Deserializer<'de>,
2017    {
2018        const FIELDS: &[&str] = &[
2019            "infos",
2020        ];
2021
2022        #[allow(clippy::enum_variant_names)]
2023        enum GeneratedField {
2024            Infos,
2025        }
2026        impl<'de> serde::Deserialize<'de> for GeneratedField {
2027            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2028            where
2029                D: serde::Deserializer<'de>,
2030            {
2031                struct GeneratedVisitor;
2032
2033                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2034                    type Value = GeneratedField;
2035
2036                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2037                        write!(formatter, "expected one of: {:?}", &FIELDS)
2038                    }
2039
2040                    #[allow(unused_variables)]
2041                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2042                    where
2043                        E: serde::de::Error,
2044                    {
2045                        match value {
2046                            "infos" => Ok(GeneratedField::Infos),
2047                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2048                        }
2049                    }
2050                }
2051                deserializer.deserialize_identifier(GeneratedVisitor)
2052            }
2053        }
2054        struct GeneratedVisitor;
2055        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2056            type Value = cancel_creating_jobs_request::CreatingJobInfos;
2057
2058            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2059                formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfos")
2060            }
2061
2062            fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfos, V::Error>
2063                where
2064                    V: serde::de::MapAccess<'de>,
2065            {
2066                let mut infos__ = None;
2067                while let Some(k) = map_.next_key()? {
2068                    match k {
2069                        GeneratedField::Infos => {
2070                            if infos__.is_some() {
2071                                return Err(serde::de::Error::duplicate_field("infos"));
2072                            }
2073                            infos__ = Some(map_.next_value()?);
2074                        }
2075                    }
2076                }
2077                Ok(cancel_creating_jobs_request::CreatingJobInfos {
2078                    infos: infos__.unwrap_or_default(),
2079                })
2080            }
2081        }
2082        deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", FIELDS, GeneratedVisitor)
2083    }
2084}
2085impl serde::Serialize for CancelCreatingJobsResponse {
2086    #[allow(deprecated)]
2087    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2088    where
2089        S: serde::Serializer,
2090    {
2091        use serde::ser::SerializeStruct;
2092        let mut len = 0;
2093        if self.status.is_some() {
2094            len += 1;
2095        }
2096        if !self.canceled_jobs.is_empty() {
2097            len += 1;
2098        }
2099        let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsResponse", len)?;
2100        if let Some(v) = self.status.as_ref() {
2101            struct_ser.serialize_field("status", v)?;
2102        }
2103        if !self.canceled_jobs.is_empty() {
2104            struct_ser.serialize_field("canceledJobs", &self.canceled_jobs)?;
2105        }
2106        struct_ser.end()
2107    }
2108}
2109impl<'de> serde::Deserialize<'de> for CancelCreatingJobsResponse {
2110    #[allow(deprecated)]
2111    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2112    where
2113        D: serde::Deserializer<'de>,
2114    {
2115        const FIELDS: &[&str] = &[
2116            "status",
2117            "canceled_jobs",
2118            "canceledJobs",
2119        ];
2120
2121        #[allow(clippy::enum_variant_names)]
2122        enum GeneratedField {
2123            Status,
2124            CanceledJobs,
2125        }
2126        impl<'de> serde::Deserialize<'de> for GeneratedField {
2127            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2128            where
2129                D: serde::Deserializer<'de>,
2130            {
2131                struct GeneratedVisitor;
2132
2133                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2134                    type Value = GeneratedField;
2135
2136                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2137                        write!(formatter, "expected one of: {:?}", &FIELDS)
2138                    }
2139
2140                    #[allow(unused_variables)]
2141                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2142                    where
2143                        E: serde::de::Error,
2144                    {
2145                        match value {
2146                            "status" => Ok(GeneratedField::Status),
2147                            "canceledJobs" | "canceled_jobs" => Ok(GeneratedField::CanceledJobs),
2148                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2149                        }
2150                    }
2151                }
2152                deserializer.deserialize_identifier(GeneratedVisitor)
2153            }
2154        }
2155        struct GeneratedVisitor;
2156        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2157            type Value = CancelCreatingJobsResponse;
2158
2159            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2160                formatter.write_str("struct meta.CancelCreatingJobsResponse")
2161            }
2162
2163            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsResponse, V::Error>
2164                where
2165                    V: serde::de::MapAccess<'de>,
2166            {
2167                let mut status__ = None;
2168                let mut canceled_jobs__ = None;
2169                while let Some(k) = map_.next_key()? {
2170                    match k {
2171                        GeneratedField::Status => {
2172                            if status__.is_some() {
2173                                return Err(serde::de::Error::duplicate_field("status"));
2174                            }
2175                            status__ = map_.next_value()?;
2176                        }
2177                        GeneratedField::CanceledJobs => {
2178                            if canceled_jobs__.is_some() {
2179                                return Err(serde::de::Error::duplicate_field("canceledJobs"));
2180                            }
2181                            canceled_jobs__ = 
2182                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2183                                    .into_iter().map(|x| x.0).collect())
2184                            ;
2185                        }
2186                    }
2187                }
2188                Ok(CancelCreatingJobsResponse {
2189                    status: status__,
2190                    canceled_jobs: canceled_jobs__.unwrap_or_default(),
2191                })
2192            }
2193        }
2194        deserializer.deserialize_struct("meta.CancelCreatingJobsResponse", FIELDS, GeneratedVisitor)
2195    }
2196}
2197impl serde::Serialize for ClusterLimit {
2198    #[allow(deprecated)]
2199    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2200    where
2201        S: serde::Serializer,
2202    {
2203        use serde::ser::SerializeStruct;
2204        let mut len = 0;
2205        if self.limit.is_some() {
2206            len += 1;
2207        }
2208        let mut struct_ser = serializer.serialize_struct("meta.ClusterLimit", len)?;
2209        if let Some(v) = self.limit.as_ref() {
2210            match v {
2211                cluster_limit::Limit::ActorCount(v) => {
2212                    struct_ser.serialize_field("actorCount", v)?;
2213                }
2214            }
2215        }
2216        struct_ser.end()
2217    }
2218}
2219impl<'de> serde::Deserialize<'de> for ClusterLimit {
2220    #[allow(deprecated)]
2221    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2222    where
2223        D: serde::Deserializer<'de>,
2224    {
2225        const FIELDS: &[&str] = &[
2226            "actor_count",
2227            "actorCount",
2228        ];
2229
2230        #[allow(clippy::enum_variant_names)]
2231        enum GeneratedField {
2232            ActorCount,
2233        }
2234        impl<'de> serde::Deserialize<'de> for GeneratedField {
2235            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2236            where
2237                D: serde::Deserializer<'de>,
2238            {
2239                struct GeneratedVisitor;
2240
2241                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2242                    type Value = GeneratedField;
2243
2244                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2245                        write!(formatter, "expected one of: {:?}", &FIELDS)
2246                    }
2247
2248                    #[allow(unused_variables)]
2249                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2250                    where
2251                        E: serde::de::Error,
2252                    {
2253                        match value {
2254                            "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
2255                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2256                        }
2257                    }
2258                }
2259                deserializer.deserialize_identifier(GeneratedVisitor)
2260            }
2261        }
2262        struct GeneratedVisitor;
2263        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2264            type Value = ClusterLimit;
2265
2266            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2267                formatter.write_str("struct meta.ClusterLimit")
2268            }
2269
2270            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClusterLimit, V::Error>
2271                where
2272                    V: serde::de::MapAccess<'de>,
2273            {
2274                let mut limit__ = None;
2275                while let Some(k) = map_.next_key()? {
2276                    match k {
2277                        GeneratedField::ActorCount => {
2278                            if limit__.is_some() {
2279                                return Err(serde::de::Error::duplicate_field("actorCount"));
2280                            }
2281                            limit__ = map_.next_value::<::std::option::Option<_>>()?.map(cluster_limit::Limit::ActorCount)
2282;
2283                        }
2284                    }
2285                }
2286                Ok(ClusterLimit {
2287                    limit: limit__,
2288                })
2289            }
2290        }
2291        deserializer.deserialize_struct("meta.ClusterLimit", FIELDS, GeneratedVisitor)
2292    }
2293}
2294impl serde::Serialize for DeleteWorkerNodeRequest {
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.host.is_some() {
2303            len += 1;
2304        }
2305        let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeRequest", len)?;
2306        if let Some(v) = self.host.as_ref() {
2307            struct_ser.serialize_field("host", v)?;
2308        }
2309        struct_ser.end()
2310    }
2311}
2312impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeRequest {
2313    #[allow(deprecated)]
2314    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2315    where
2316        D: serde::Deserializer<'de>,
2317    {
2318        const FIELDS: &[&str] = &[
2319            "host",
2320        ];
2321
2322        #[allow(clippy::enum_variant_names)]
2323        enum GeneratedField {
2324            Host,
2325        }
2326        impl<'de> serde::Deserialize<'de> for GeneratedField {
2327            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2328            where
2329                D: serde::Deserializer<'de>,
2330            {
2331                struct GeneratedVisitor;
2332
2333                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2334                    type Value = GeneratedField;
2335
2336                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2337                        write!(formatter, "expected one of: {:?}", &FIELDS)
2338                    }
2339
2340                    #[allow(unused_variables)]
2341                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2342                    where
2343                        E: serde::de::Error,
2344                    {
2345                        match value {
2346                            "host" => Ok(GeneratedField::Host),
2347                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2348                        }
2349                    }
2350                }
2351                deserializer.deserialize_identifier(GeneratedVisitor)
2352            }
2353        }
2354        struct GeneratedVisitor;
2355        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2356            type Value = DeleteWorkerNodeRequest;
2357
2358            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2359                formatter.write_str("struct meta.DeleteWorkerNodeRequest")
2360            }
2361
2362            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeRequest, V::Error>
2363                where
2364                    V: serde::de::MapAccess<'de>,
2365            {
2366                let mut host__ = None;
2367                while let Some(k) = map_.next_key()? {
2368                    match k {
2369                        GeneratedField::Host => {
2370                            if host__.is_some() {
2371                                return Err(serde::de::Error::duplicate_field("host"));
2372                            }
2373                            host__ = map_.next_value()?;
2374                        }
2375                    }
2376                }
2377                Ok(DeleteWorkerNodeRequest {
2378                    host: host__,
2379                })
2380            }
2381        }
2382        deserializer.deserialize_struct("meta.DeleteWorkerNodeRequest", FIELDS, GeneratedVisitor)
2383    }
2384}
2385impl serde::Serialize for DeleteWorkerNodeResponse {
2386    #[allow(deprecated)]
2387    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2388    where
2389        S: serde::Serializer,
2390    {
2391        use serde::ser::SerializeStruct;
2392        let mut len = 0;
2393        if self.status.is_some() {
2394            len += 1;
2395        }
2396        let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeResponse", len)?;
2397        if let Some(v) = self.status.as_ref() {
2398            struct_ser.serialize_field("status", v)?;
2399        }
2400        struct_ser.end()
2401    }
2402}
2403impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeResponse {
2404    #[allow(deprecated)]
2405    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2406    where
2407        D: serde::Deserializer<'de>,
2408    {
2409        const FIELDS: &[&str] = &[
2410            "status",
2411        ];
2412
2413        #[allow(clippy::enum_variant_names)]
2414        enum GeneratedField {
2415            Status,
2416        }
2417        impl<'de> serde::Deserialize<'de> for GeneratedField {
2418            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2419            where
2420                D: serde::Deserializer<'de>,
2421            {
2422                struct GeneratedVisitor;
2423
2424                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2425                    type Value = GeneratedField;
2426
2427                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2428                        write!(formatter, "expected one of: {:?}", &FIELDS)
2429                    }
2430
2431                    #[allow(unused_variables)]
2432                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2433                    where
2434                        E: serde::de::Error,
2435                    {
2436                        match value {
2437                            "status" => Ok(GeneratedField::Status),
2438                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2439                        }
2440                    }
2441                }
2442                deserializer.deserialize_identifier(GeneratedVisitor)
2443            }
2444        }
2445        struct GeneratedVisitor;
2446        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2447            type Value = DeleteWorkerNodeResponse;
2448
2449            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2450                formatter.write_str("struct meta.DeleteWorkerNodeResponse")
2451            }
2452
2453            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeResponse, V::Error>
2454                where
2455                    V: serde::de::MapAccess<'de>,
2456            {
2457                let mut status__ = None;
2458                while let Some(k) = map_.next_key()? {
2459                    match k {
2460                        GeneratedField::Status => {
2461                            if status__.is_some() {
2462                                return Err(serde::de::Error::duplicate_field("status"));
2463                            }
2464                            status__ = map_.next_value()?;
2465                        }
2466                    }
2467                }
2468                Ok(DeleteWorkerNodeResponse {
2469                    status: status__,
2470                })
2471            }
2472        }
2473        deserializer.deserialize_struct("meta.DeleteWorkerNodeResponse", FIELDS, GeneratedVisitor)
2474    }
2475}
2476impl serde::Serialize for EventLog {
2477    #[allow(deprecated)]
2478    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2479    where
2480        S: serde::Serializer,
2481    {
2482        use serde::ser::SerializeStruct;
2483        let mut len = 0;
2484        if self.unique_id.is_some() {
2485            len += 1;
2486        }
2487        if self.timestamp.is_some() {
2488            len += 1;
2489        }
2490        if self.event.is_some() {
2491            len += 1;
2492        }
2493        let mut struct_ser = serializer.serialize_struct("meta.EventLog", len)?;
2494        if let Some(v) = self.unique_id.as_ref() {
2495            struct_ser.serialize_field("uniqueId", v)?;
2496        }
2497        if let Some(v) = self.timestamp.as_ref() {
2498            #[allow(clippy::needless_borrow)]
2499            #[allow(clippy::needless_borrows_for_generic_args)]
2500            struct_ser.serialize_field("timestamp", ToString::to_string(&v).as_str())?;
2501        }
2502        if let Some(v) = self.event.as_ref() {
2503            match v {
2504                event_log::Event::CreateStreamJobFail(v) => {
2505                    struct_ser.serialize_field("createStreamJobFail", v)?;
2506                }
2507                event_log::Event::DirtyStreamJobClear(v) => {
2508                    struct_ser.serialize_field("dirtyStreamJobClear", v)?;
2509                }
2510                event_log::Event::MetaNodeStart(v) => {
2511                    struct_ser.serialize_field("metaNodeStart", v)?;
2512                }
2513                event_log::Event::BarrierComplete(v) => {
2514                    struct_ser.serialize_field("barrierComplete", v)?;
2515                }
2516                event_log::Event::InjectBarrierFail(v) => {
2517                    struct_ser.serialize_field("injectBarrierFail", v)?;
2518                }
2519                event_log::Event::CollectBarrierFail(v) => {
2520                    struct_ser.serialize_field("collectBarrierFail", v)?;
2521                }
2522                event_log::Event::WorkerNodePanic(v) => {
2523                    struct_ser.serialize_field("workerNodePanic", v)?;
2524                }
2525                event_log::Event::AutoSchemaChangeFail(v) => {
2526                    struct_ser.serialize_field("autoSchemaChangeFail", v)?;
2527                }
2528                event_log::Event::SinkFail(v) => {
2529                    struct_ser.serialize_field("sinkFail", v)?;
2530                }
2531                event_log::Event::Recovery(v) => {
2532                    struct_ser.serialize_field("recovery", v)?;
2533                }
2534            }
2535        }
2536        struct_ser.end()
2537    }
2538}
2539impl<'de> serde::Deserialize<'de> for EventLog {
2540    #[allow(deprecated)]
2541    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2542    where
2543        D: serde::Deserializer<'de>,
2544    {
2545        const FIELDS: &[&str] = &[
2546            "unique_id",
2547            "uniqueId",
2548            "timestamp",
2549            "create_stream_job_fail",
2550            "createStreamJobFail",
2551            "dirty_stream_job_clear",
2552            "dirtyStreamJobClear",
2553            "meta_node_start",
2554            "metaNodeStart",
2555            "barrier_complete",
2556            "barrierComplete",
2557            "inject_barrier_fail",
2558            "injectBarrierFail",
2559            "collect_barrier_fail",
2560            "collectBarrierFail",
2561            "worker_node_panic",
2562            "workerNodePanic",
2563            "auto_schema_change_fail",
2564            "autoSchemaChangeFail",
2565            "sink_fail",
2566            "sinkFail",
2567            "recovery",
2568        ];
2569
2570        #[allow(clippy::enum_variant_names)]
2571        enum GeneratedField {
2572            UniqueId,
2573            Timestamp,
2574            CreateStreamJobFail,
2575            DirtyStreamJobClear,
2576            MetaNodeStart,
2577            BarrierComplete,
2578            InjectBarrierFail,
2579            CollectBarrierFail,
2580            WorkerNodePanic,
2581            AutoSchemaChangeFail,
2582            SinkFail,
2583            Recovery,
2584        }
2585        impl<'de> serde::Deserialize<'de> for GeneratedField {
2586            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2587            where
2588                D: serde::Deserializer<'de>,
2589            {
2590                struct GeneratedVisitor;
2591
2592                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2593                    type Value = GeneratedField;
2594
2595                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2596                        write!(formatter, "expected one of: {:?}", &FIELDS)
2597                    }
2598
2599                    #[allow(unused_variables)]
2600                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2601                    where
2602                        E: serde::de::Error,
2603                    {
2604                        match value {
2605                            "uniqueId" | "unique_id" => Ok(GeneratedField::UniqueId),
2606                            "timestamp" => Ok(GeneratedField::Timestamp),
2607                            "createStreamJobFail" | "create_stream_job_fail" => Ok(GeneratedField::CreateStreamJobFail),
2608                            "dirtyStreamJobClear" | "dirty_stream_job_clear" => Ok(GeneratedField::DirtyStreamJobClear),
2609                            "metaNodeStart" | "meta_node_start" => Ok(GeneratedField::MetaNodeStart),
2610                            "barrierComplete" | "barrier_complete" => Ok(GeneratedField::BarrierComplete),
2611                            "injectBarrierFail" | "inject_barrier_fail" => Ok(GeneratedField::InjectBarrierFail),
2612                            "collectBarrierFail" | "collect_barrier_fail" => Ok(GeneratedField::CollectBarrierFail),
2613                            "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
2614                            "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
2615                            "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
2616                            "recovery" => Ok(GeneratedField::Recovery),
2617                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2618                        }
2619                    }
2620                }
2621                deserializer.deserialize_identifier(GeneratedVisitor)
2622            }
2623        }
2624        struct GeneratedVisitor;
2625        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2626            type Value = EventLog;
2627
2628            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2629                formatter.write_str("struct meta.EventLog")
2630            }
2631
2632            fn visit_map<V>(self, mut map_: V) -> std::result::Result<EventLog, V::Error>
2633                where
2634                    V: serde::de::MapAccess<'de>,
2635            {
2636                let mut unique_id__ = None;
2637                let mut timestamp__ = None;
2638                let mut event__ = None;
2639                while let Some(k) = map_.next_key()? {
2640                    match k {
2641                        GeneratedField::UniqueId => {
2642                            if unique_id__.is_some() {
2643                                return Err(serde::de::Error::duplicate_field("uniqueId"));
2644                            }
2645                            unique_id__ = map_.next_value()?;
2646                        }
2647                        GeneratedField::Timestamp => {
2648                            if timestamp__.is_some() {
2649                                return Err(serde::de::Error::duplicate_field("timestamp"));
2650                            }
2651                            timestamp__ = 
2652                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2653                            ;
2654                        }
2655                        GeneratedField::CreateStreamJobFail => {
2656                            if event__.is_some() {
2657                                return Err(serde::de::Error::duplicate_field("createStreamJobFail"));
2658                            }
2659                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CreateStreamJobFail)
2660;
2661                        }
2662                        GeneratedField::DirtyStreamJobClear => {
2663                            if event__.is_some() {
2664                                return Err(serde::de::Error::duplicate_field("dirtyStreamJobClear"));
2665                            }
2666                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::DirtyStreamJobClear)
2667;
2668                        }
2669                        GeneratedField::MetaNodeStart => {
2670                            if event__.is_some() {
2671                                return Err(serde::de::Error::duplicate_field("metaNodeStart"));
2672                            }
2673                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::MetaNodeStart)
2674;
2675                        }
2676                        GeneratedField::BarrierComplete => {
2677                            if event__.is_some() {
2678                                return Err(serde::de::Error::duplicate_field("barrierComplete"));
2679                            }
2680                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::BarrierComplete)
2681;
2682                        }
2683                        GeneratedField::InjectBarrierFail => {
2684                            if event__.is_some() {
2685                                return Err(serde::de::Error::duplicate_field("injectBarrierFail"));
2686                            }
2687                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::InjectBarrierFail)
2688;
2689                        }
2690                        GeneratedField::CollectBarrierFail => {
2691                            if event__.is_some() {
2692                                return Err(serde::de::Error::duplicate_field("collectBarrierFail"));
2693                            }
2694                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CollectBarrierFail)
2695;
2696                        }
2697                        GeneratedField::WorkerNodePanic => {
2698                            if event__.is_some() {
2699                                return Err(serde::de::Error::duplicate_field("workerNodePanic"));
2700                            }
2701                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::WorkerNodePanic)
2702;
2703                        }
2704                        GeneratedField::AutoSchemaChangeFail => {
2705                            if event__.is_some() {
2706                                return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
2707                            }
2708                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::AutoSchemaChangeFail)
2709;
2710                        }
2711                        GeneratedField::SinkFail => {
2712                            if event__.is_some() {
2713                                return Err(serde::de::Error::duplicate_field("sinkFail"));
2714                            }
2715                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::SinkFail)
2716;
2717                        }
2718                        GeneratedField::Recovery => {
2719                            if event__.is_some() {
2720                                return Err(serde::de::Error::duplicate_field("recovery"));
2721                            }
2722                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::Recovery)
2723;
2724                        }
2725                    }
2726                }
2727                Ok(EventLog {
2728                    unique_id: unique_id__,
2729                    timestamp: timestamp__,
2730                    event: event__,
2731                })
2732            }
2733        }
2734        deserializer.deserialize_struct("meta.EventLog", FIELDS, GeneratedVisitor)
2735    }
2736}
2737impl serde::Serialize for event_log::EventAutoSchemaChangeFail {
2738    #[allow(deprecated)]
2739    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2740    where
2741        S: serde::Serializer,
2742    {
2743        use serde::ser::SerializeStruct;
2744        let mut len = 0;
2745        if self.table_id != 0 {
2746            len += 1;
2747        }
2748        if !self.table_name.is_empty() {
2749            len += 1;
2750        }
2751        if !self.cdc_table_id.is_empty() {
2752            len += 1;
2753        }
2754        if !self.upstream_ddl.is_empty() {
2755            len += 1;
2756        }
2757        if !self.fail_info.is_empty() {
2758            len += 1;
2759        }
2760        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventAutoSchemaChangeFail", len)?;
2761        if self.table_id != 0 {
2762            struct_ser.serialize_field("tableId", &self.table_id)?;
2763        }
2764        if !self.table_name.is_empty() {
2765            struct_ser.serialize_field("tableName", &self.table_name)?;
2766        }
2767        if !self.cdc_table_id.is_empty() {
2768            struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
2769        }
2770        if !self.upstream_ddl.is_empty() {
2771            struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
2772        }
2773        if !self.fail_info.is_empty() {
2774            struct_ser.serialize_field("failInfo", &self.fail_info)?;
2775        }
2776        struct_ser.end()
2777    }
2778}
2779impl<'de> serde::Deserialize<'de> for event_log::EventAutoSchemaChangeFail {
2780    #[allow(deprecated)]
2781    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2782    where
2783        D: serde::Deserializer<'de>,
2784    {
2785        const FIELDS: &[&str] = &[
2786            "table_id",
2787            "tableId",
2788            "table_name",
2789            "tableName",
2790            "cdc_table_id",
2791            "cdcTableId",
2792            "upstream_ddl",
2793            "upstreamDdl",
2794            "fail_info",
2795            "failInfo",
2796        ];
2797
2798        #[allow(clippy::enum_variant_names)]
2799        enum GeneratedField {
2800            TableId,
2801            TableName,
2802            CdcTableId,
2803            UpstreamDdl,
2804            FailInfo,
2805        }
2806        impl<'de> serde::Deserialize<'de> for GeneratedField {
2807            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2808            where
2809                D: serde::Deserializer<'de>,
2810            {
2811                struct GeneratedVisitor;
2812
2813                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2814                    type Value = GeneratedField;
2815
2816                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2817                        write!(formatter, "expected one of: {:?}", &FIELDS)
2818                    }
2819
2820                    #[allow(unused_variables)]
2821                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2822                    where
2823                        E: serde::de::Error,
2824                    {
2825                        match value {
2826                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
2827                            "tableName" | "table_name" => Ok(GeneratedField::TableName),
2828                            "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
2829                            "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
2830                            "failInfo" | "fail_info" => Ok(GeneratedField::FailInfo),
2831                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2832                        }
2833                    }
2834                }
2835                deserializer.deserialize_identifier(GeneratedVisitor)
2836            }
2837        }
2838        struct GeneratedVisitor;
2839        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2840            type Value = event_log::EventAutoSchemaChangeFail;
2841
2842            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2843                formatter.write_str("struct meta.EventLog.EventAutoSchemaChangeFail")
2844            }
2845
2846            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventAutoSchemaChangeFail, V::Error>
2847                where
2848                    V: serde::de::MapAccess<'de>,
2849            {
2850                let mut table_id__ = None;
2851                let mut table_name__ = None;
2852                let mut cdc_table_id__ = None;
2853                let mut upstream_ddl__ = None;
2854                let mut fail_info__ = None;
2855                while let Some(k) = map_.next_key()? {
2856                    match k {
2857                        GeneratedField::TableId => {
2858                            if table_id__.is_some() {
2859                                return Err(serde::de::Error::duplicate_field("tableId"));
2860                            }
2861                            table_id__ = 
2862                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2863                            ;
2864                        }
2865                        GeneratedField::TableName => {
2866                            if table_name__.is_some() {
2867                                return Err(serde::de::Error::duplicate_field("tableName"));
2868                            }
2869                            table_name__ = Some(map_.next_value()?);
2870                        }
2871                        GeneratedField::CdcTableId => {
2872                            if cdc_table_id__.is_some() {
2873                                return Err(serde::de::Error::duplicate_field("cdcTableId"));
2874                            }
2875                            cdc_table_id__ = Some(map_.next_value()?);
2876                        }
2877                        GeneratedField::UpstreamDdl => {
2878                            if upstream_ddl__.is_some() {
2879                                return Err(serde::de::Error::duplicate_field("upstreamDdl"));
2880                            }
2881                            upstream_ddl__ = Some(map_.next_value()?);
2882                        }
2883                        GeneratedField::FailInfo => {
2884                            if fail_info__.is_some() {
2885                                return Err(serde::de::Error::duplicate_field("failInfo"));
2886                            }
2887                            fail_info__ = Some(map_.next_value()?);
2888                        }
2889                    }
2890                }
2891                Ok(event_log::EventAutoSchemaChangeFail {
2892                    table_id: table_id__.unwrap_or_default(),
2893                    table_name: table_name__.unwrap_or_default(),
2894                    cdc_table_id: cdc_table_id__.unwrap_or_default(),
2895                    upstream_ddl: upstream_ddl__.unwrap_or_default(),
2896                    fail_info: fail_info__.unwrap_or_default(),
2897                })
2898            }
2899        }
2900        deserializer.deserialize_struct("meta.EventLog.EventAutoSchemaChangeFail", FIELDS, GeneratedVisitor)
2901    }
2902}
2903impl serde::Serialize for event_log::EventBarrierComplete {
2904    #[allow(deprecated)]
2905    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2906    where
2907        S: serde::Serializer,
2908    {
2909        use serde::ser::SerializeStruct;
2910        let mut len = 0;
2911        if self.prev_epoch != 0 {
2912            len += 1;
2913        }
2914        if self.cur_epoch != 0 {
2915            len += 1;
2916        }
2917        if self.duration_sec != 0. {
2918            len += 1;
2919        }
2920        if !self.command.is_empty() {
2921            len += 1;
2922        }
2923        if !self.barrier_kind.is_empty() {
2924            len += 1;
2925        }
2926        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventBarrierComplete", len)?;
2927        if self.prev_epoch != 0 {
2928            #[allow(clippy::needless_borrow)]
2929            #[allow(clippy::needless_borrows_for_generic_args)]
2930            struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
2931        }
2932        if self.cur_epoch != 0 {
2933            #[allow(clippy::needless_borrow)]
2934            #[allow(clippy::needless_borrows_for_generic_args)]
2935            struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
2936        }
2937        if self.duration_sec != 0. {
2938            struct_ser.serialize_field("durationSec", &self.duration_sec)?;
2939        }
2940        if !self.command.is_empty() {
2941            struct_ser.serialize_field("command", &self.command)?;
2942        }
2943        if !self.barrier_kind.is_empty() {
2944            struct_ser.serialize_field("barrierKind", &self.barrier_kind)?;
2945        }
2946        struct_ser.end()
2947    }
2948}
2949impl<'de> serde::Deserialize<'de> for event_log::EventBarrierComplete {
2950    #[allow(deprecated)]
2951    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2952    where
2953        D: serde::Deserializer<'de>,
2954    {
2955        const FIELDS: &[&str] = &[
2956            "prev_epoch",
2957            "prevEpoch",
2958            "cur_epoch",
2959            "curEpoch",
2960            "duration_sec",
2961            "durationSec",
2962            "command",
2963            "barrier_kind",
2964            "barrierKind",
2965        ];
2966
2967        #[allow(clippy::enum_variant_names)]
2968        enum GeneratedField {
2969            PrevEpoch,
2970            CurEpoch,
2971            DurationSec,
2972            Command,
2973            BarrierKind,
2974        }
2975        impl<'de> serde::Deserialize<'de> for GeneratedField {
2976            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2977            where
2978                D: serde::Deserializer<'de>,
2979            {
2980                struct GeneratedVisitor;
2981
2982                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2983                    type Value = GeneratedField;
2984
2985                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2986                        write!(formatter, "expected one of: {:?}", &FIELDS)
2987                    }
2988
2989                    #[allow(unused_variables)]
2990                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2991                    where
2992                        E: serde::de::Error,
2993                    {
2994                        match value {
2995                            "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
2996                            "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
2997                            "durationSec" | "duration_sec" => Ok(GeneratedField::DurationSec),
2998                            "command" => Ok(GeneratedField::Command),
2999                            "barrierKind" | "barrier_kind" => Ok(GeneratedField::BarrierKind),
3000                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3001                        }
3002                    }
3003                }
3004                deserializer.deserialize_identifier(GeneratedVisitor)
3005            }
3006        }
3007        struct GeneratedVisitor;
3008        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3009            type Value = event_log::EventBarrierComplete;
3010
3011            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3012                formatter.write_str("struct meta.EventLog.EventBarrierComplete")
3013            }
3014
3015            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventBarrierComplete, V::Error>
3016                where
3017                    V: serde::de::MapAccess<'de>,
3018            {
3019                let mut prev_epoch__ = None;
3020                let mut cur_epoch__ = None;
3021                let mut duration_sec__ = None;
3022                let mut command__ = None;
3023                let mut barrier_kind__ = None;
3024                while let Some(k) = map_.next_key()? {
3025                    match k {
3026                        GeneratedField::PrevEpoch => {
3027                            if prev_epoch__.is_some() {
3028                                return Err(serde::de::Error::duplicate_field("prevEpoch"));
3029                            }
3030                            prev_epoch__ = 
3031                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3032                            ;
3033                        }
3034                        GeneratedField::CurEpoch => {
3035                            if cur_epoch__.is_some() {
3036                                return Err(serde::de::Error::duplicate_field("curEpoch"));
3037                            }
3038                            cur_epoch__ = 
3039                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3040                            ;
3041                        }
3042                        GeneratedField::DurationSec => {
3043                            if duration_sec__.is_some() {
3044                                return Err(serde::de::Error::duplicate_field("durationSec"));
3045                            }
3046                            duration_sec__ = 
3047                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3048                            ;
3049                        }
3050                        GeneratedField::Command => {
3051                            if command__.is_some() {
3052                                return Err(serde::de::Error::duplicate_field("command"));
3053                            }
3054                            command__ = Some(map_.next_value()?);
3055                        }
3056                        GeneratedField::BarrierKind => {
3057                            if barrier_kind__.is_some() {
3058                                return Err(serde::de::Error::duplicate_field("barrierKind"));
3059                            }
3060                            barrier_kind__ = Some(map_.next_value()?);
3061                        }
3062                    }
3063                }
3064                Ok(event_log::EventBarrierComplete {
3065                    prev_epoch: prev_epoch__.unwrap_or_default(),
3066                    cur_epoch: cur_epoch__.unwrap_or_default(),
3067                    duration_sec: duration_sec__.unwrap_or_default(),
3068                    command: command__.unwrap_or_default(),
3069                    barrier_kind: barrier_kind__.unwrap_or_default(),
3070                })
3071            }
3072        }
3073        deserializer.deserialize_struct("meta.EventLog.EventBarrierComplete", FIELDS, GeneratedVisitor)
3074    }
3075}
3076impl serde::Serialize for event_log::EventCollectBarrierFail {
3077    #[allow(deprecated)]
3078    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3079    where
3080        S: serde::Serializer,
3081    {
3082        use serde::ser::SerializeStruct;
3083        let mut len = 0;
3084        if !self.error.is_empty() {
3085            len += 1;
3086        }
3087        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCollectBarrierFail", len)?;
3088        if !self.error.is_empty() {
3089            struct_ser.serialize_field("error", &self.error)?;
3090        }
3091        struct_ser.end()
3092    }
3093}
3094impl<'de> serde::Deserialize<'de> for event_log::EventCollectBarrierFail {
3095    #[allow(deprecated)]
3096    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3097    where
3098        D: serde::Deserializer<'de>,
3099    {
3100        const FIELDS: &[&str] = &[
3101            "error",
3102        ];
3103
3104        #[allow(clippy::enum_variant_names)]
3105        enum GeneratedField {
3106            Error,
3107        }
3108        impl<'de> serde::Deserialize<'de> for GeneratedField {
3109            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3110            where
3111                D: serde::Deserializer<'de>,
3112            {
3113                struct GeneratedVisitor;
3114
3115                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3116                    type Value = GeneratedField;
3117
3118                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3119                        write!(formatter, "expected one of: {:?}", &FIELDS)
3120                    }
3121
3122                    #[allow(unused_variables)]
3123                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3124                    where
3125                        E: serde::de::Error,
3126                    {
3127                        match value {
3128                            "error" => Ok(GeneratedField::Error),
3129                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3130                        }
3131                    }
3132                }
3133                deserializer.deserialize_identifier(GeneratedVisitor)
3134            }
3135        }
3136        struct GeneratedVisitor;
3137        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3138            type Value = event_log::EventCollectBarrierFail;
3139
3140            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3141                formatter.write_str("struct meta.EventLog.EventCollectBarrierFail")
3142            }
3143
3144            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCollectBarrierFail, V::Error>
3145                where
3146                    V: serde::de::MapAccess<'de>,
3147            {
3148                let mut error__ = None;
3149                while let Some(k) = map_.next_key()? {
3150                    match k {
3151                        GeneratedField::Error => {
3152                            if error__.is_some() {
3153                                return Err(serde::de::Error::duplicate_field("error"));
3154                            }
3155                            error__ = Some(map_.next_value()?);
3156                        }
3157                    }
3158                }
3159                Ok(event_log::EventCollectBarrierFail {
3160                    error: error__.unwrap_or_default(),
3161                })
3162            }
3163        }
3164        deserializer.deserialize_struct("meta.EventLog.EventCollectBarrierFail", FIELDS, GeneratedVisitor)
3165    }
3166}
3167impl serde::Serialize for event_log::EventCreateStreamJobFail {
3168    #[allow(deprecated)]
3169    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3170    where
3171        S: serde::Serializer,
3172    {
3173        use serde::ser::SerializeStruct;
3174        let mut len = 0;
3175        if self.id != 0 {
3176            len += 1;
3177        }
3178        if !self.name.is_empty() {
3179            len += 1;
3180        }
3181        if !self.definition.is_empty() {
3182            len += 1;
3183        }
3184        if !self.error.is_empty() {
3185            len += 1;
3186        }
3187        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCreateStreamJobFail", len)?;
3188        if self.id != 0 {
3189            struct_ser.serialize_field("id", &self.id)?;
3190        }
3191        if !self.name.is_empty() {
3192            struct_ser.serialize_field("name", &self.name)?;
3193        }
3194        if !self.definition.is_empty() {
3195            struct_ser.serialize_field("definition", &self.definition)?;
3196        }
3197        if !self.error.is_empty() {
3198            struct_ser.serialize_field("error", &self.error)?;
3199        }
3200        struct_ser.end()
3201    }
3202}
3203impl<'de> serde::Deserialize<'de> for event_log::EventCreateStreamJobFail {
3204    #[allow(deprecated)]
3205    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3206    where
3207        D: serde::Deserializer<'de>,
3208    {
3209        const FIELDS: &[&str] = &[
3210            "id",
3211            "name",
3212            "definition",
3213            "error",
3214        ];
3215
3216        #[allow(clippy::enum_variant_names)]
3217        enum GeneratedField {
3218            Id,
3219            Name,
3220            Definition,
3221            Error,
3222        }
3223        impl<'de> serde::Deserialize<'de> for GeneratedField {
3224            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3225            where
3226                D: serde::Deserializer<'de>,
3227            {
3228                struct GeneratedVisitor;
3229
3230                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3231                    type Value = GeneratedField;
3232
3233                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3234                        write!(formatter, "expected one of: {:?}", &FIELDS)
3235                    }
3236
3237                    #[allow(unused_variables)]
3238                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3239                    where
3240                        E: serde::de::Error,
3241                    {
3242                        match value {
3243                            "id" => Ok(GeneratedField::Id),
3244                            "name" => Ok(GeneratedField::Name),
3245                            "definition" => Ok(GeneratedField::Definition),
3246                            "error" => Ok(GeneratedField::Error),
3247                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3248                        }
3249                    }
3250                }
3251                deserializer.deserialize_identifier(GeneratedVisitor)
3252            }
3253        }
3254        struct GeneratedVisitor;
3255        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3256            type Value = event_log::EventCreateStreamJobFail;
3257
3258            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3259                formatter.write_str("struct meta.EventLog.EventCreateStreamJobFail")
3260            }
3261
3262            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCreateStreamJobFail, V::Error>
3263                where
3264                    V: serde::de::MapAccess<'de>,
3265            {
3266                let mut id__ = None;
3267                let mut name__ = None;
3268                let mut definition__ = None;
3269                let mut error__ = None;
3270                while let Some(k) = map_.next_key()? {
3271                    match k {
3272                        GeneratedField::Id => {
3273                            if id__.is_some() {
3274                                return Err(serde::de::Error::duplicate_field("id"));
3275                            }
3276                            id__ = 
3277                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3278                            ;
3279                        }
3280                        GeneratedField::Name => {
3281                            if name__.is_some() {
3282                                return Err(serde::de::Error::duplicate_field("name"));
3283                            }
3284                            name__ = Some(map_.next_value()?);
3285                        }
3286                        GeneratedField::Definition => {
3287                            if definition__.is_some() {
3288                                return Err(serde::de::Error::duplicate_field("definition"));
3289                            }
3290                            definition__ = Some(map_.next_value()?);
3291                        }
3292                        GeneratedField::Error => {
3293                            if error__.is_some() {
3294                                return Err(serde::de::Error::duplicate_field("error"));
3295                            }
3296                            error__ = Some(map_.next_value()?);
3297                        }
3298                    }
3299                }
3300                Ok(event_log::EventCreateStreamJobFail {
3301                    id: id__.unwrap_or_default(),
3302                    name: name__.unwrap_or_default(),
3303                    definition: definition__.unwrap_or_default(),
3304                    error: error__.unwrap_or_default(),
3305                })
3306            }
3307        }
3308        deserializer.deserialize_struct("meta.EventLog.EventCreateStreamJobFail", FIELDS, GeneratedVisitor)
3309    }
3310}
3311impl serde::Serialize for event_log::EventDirtyStreamJobClear {
3312    #[allow(deprecated)]
3313    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3314    where
3315        S: serde::Serializer,
3316    {
3317        use serde::ser::SerializeStruct;
3318        let mut len = 0;
3319        if self.id != 0 {
3320            len += 1;
3321        }
3322        if !self.name.is_empty() {
3323            len += 1;
3324        }
3325        if !self.definition.is_empty() {
3326            len += 1;
3327        }
3328        if !self.error.is_empty() {
3329            len += 1;
3330        }
3331        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventDirtyStreamJobClear", len)?;
3332        if self.id != 0 {
3333            struct_ser.serialize_field("id", &self.id)?;
3334        }
3335        if !self.name.is_empty() {
3336            struct_ser.serialize_field("name", &self.name)?;
3337        }
3338        if !self.definition.is_empty() {
3339            struct_ser.serialize_field("definition", &self.definition)?;
3340        }
3341        if !self.error.is_empty() {
3342            struct_ser.serialize_field("error", &self.error)?;
3343        }
3344        struct_ser.end()
3345    }
3346}
3347impl<'de> serde::Deserialize<'de> for event_log::EventDirtyStreamJobClear {
3348    #[allow(deprecated)]
3349    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3350    where
3351        D: serde::Deserializer<'de>,
3352    {
3353        const FIELDS: &[&str] = &[
3354            "id",
3355            "name",
3356            "definition",
3357            "error",
3358        ];
3359
3360        #[allow(clippy::enum_variant_names)]
3361        enum GeneratedField {
3362            Id,
3363            Name,
3364            Definition,
3365            Error,
3366        }
3367        impl<'de> serde::Deserialize<'de> for GeneratedField {
3368            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3369            where
3370                D: serde::Deserializer<'de>,
3371            {
3372                struct GeneratedVisitor;
3373
3374                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3375                    type Value = GeneratedField;
3376
3377                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3378                        write!(formatter, "expected one of: {:?}", &FIELDS)
3379                    }
3380
3381                    #[allow(unused_variables)]
3382                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3383                    where
3384                        E: serde::de::Error,
3385                    {
3386                        match value {
3387                            "id" => Ok(GeneratedField::Id),
3388                            "name" => Ok(GeneratedField::Name),
3389                            "definition" => Ok(GeneratedField::Definition),
3390                            "error" => Ok(GeneratedField::Error),
3391                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3392                        }
3393                    }
3394                }
3395                deserializer.deserialize_identifier(GeneratedVisitor)
3396            }
3397        }
3398        struct GeneratedVisitor;
3399        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3400            type Value = event_log::EventDirtyStreamJobClear;
3401
3402            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3403                formatter.write_str("struct meta.EventLog.EventDirtyStreamJobClear")
3404            }
3405
3406            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventDirtyStreamJobClear, V::Error>
3407                where
3408                    V: serde::de::MapAccess<'de>,
3409            {
3410                let mut id__ = None;
3411                let mut name__ = None;
3412                let mut definition__ = None;
3413                let mut error__ = None;
3414                while let Some(k) = map_.next_key()? {
3415                    match k {
3416                        GeneratedField::Id => {
3417                            if id__.is_some() {
3418                                return Err(serde::de::Error::duplicate_field("id"));
3419                            }
3420                            id__ = 
3421                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3422                            ;
3423                        }
3424                        GeneratedField::Name => {
3425                            if name__.is_some() {
3426                                return Err(serde::de::Error::duplicate_field("name"));
3427                            }
3428                            name__ = Some(map_.next_value()?);
3429                        }
3430                        GeneratedField::Definition => {
3431                            if definition__.is_some() {
3432                                return Err(serde::de::Error::duplicate_field("definition"));
3433                            }
3434                            definition__ = Some(map_.next_value()?);
3435                        }
3436                        GeneratedField::Error => {
3437                            if error__.is_some() {
3438                                return Err(serde::de::Error::duplicate_field("error"));
3439                            }
3440                            error__ = Some(map_.next_value()?);
3441                        }
3442                    }
3443                }
3444                Ok(event_log::EventDirtyStreamJobClear {
3445                    id: id__.unwrap_or_default(),
3446                    name: name__.unwrap_or_default(),
3447                    definition: definition__.unwrap_or_default(),
3448                    error: error__.unwrap_or_default(),
3449                })
3450            }
3451        }
3452        deserializer.deserialize_struct("meta.EventLog.EventDirtyStreamJobClear", FIELDS, GeneratedVisitor)
3453    }
3454}
3455impl serde::Serialize for event_log::EventInjectBarrierFail {
3456    #[allow(deprecated)]
3457    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3458    where
3459        S: serde::Serializer,
3460    {
3461        use serde::ser::SerializeStruct;
3462        let mut len = 0;
3463        if self.prev_epoch != 0 {
3464            len += 1;
3465        }
3466        if self.cur_epoch != 0 {
3467            len += 1;
3468        }
3469        if !self.error.is_empty() {
3470            len += 1;
3471        }
3472        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventInjectBarrierFail", len)?;
3473        if self.prev_epoch != 0 {
3474            #[allow(clippy::needless_borrow)]
3475            #[allow(clippy::needless_borrows_for_generic_args)]
3476            struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3477        }
3478        if self.cur_epoch != 0 {
3479            #[allow(clippy::needless_borrow)]
3480            #[allow(clippy::needless_borrows_for_generic_args)]
3481            struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3482        }
3483        if !self.error.is_empty() {
3484            struct_ser.serialize_field("error", &self.error)?;
3485        }
3486        struct_ser.end()
3487    }
3488}
3489impl<'de> serde::Deserialize<'de> for event_log::EventInjectBarrierFail {
3490    #[allow(deprecated)]
3491    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3492    where
3493        D: serde::Deserializer<'de>,
3494    {
3495        const FIELDS: &[&str] = &[
3496            "prev_epoch",
3497            "prevEpoch",
3498            "cur_epoch",
3499            "curEpoch",
3500            "error",
3501        ];
3502
3503        #[allow(clippy::enum_variant_names)]
3504        enum GeneratedField {
3505            PrevEpoch,
3506            CurEpoch,
3507            Error,
3508        }
3509        impl<'de> serde::Deserialize<'de> for GeneratedField {
3510            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3511            where
3512                D: serde::Deserializer<'de>,
3513            {
3514                struct GeneratedVisitor;
3515
3516                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3517                    type Value = GeneratedField;
3518
3519                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3520                        write!(formatter, "expected one of: {:?}", &FIELDS)
3521                    }
3522
3523                    #[allow(unused_variables)]
3524                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3525                    where
3526                        E: serde::de::Error,
3527                    {
3528                        match value {
3529                            "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3530                            "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3531                            "error" => Ok(GeneratedField::Error),
3532                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3533                        }
3534                    }
3535                }
3536                deserializer.deserialize_identifier(GeneratedVisitor)
3537            }
3538        }
3539        struct GeneratedVisitor;
3540        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3541            type Value = event_log::EventInjectBarrierFail;
3542
3543            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3544                formatter.write_str("struct meta.EventLog.EventInjectBarrierFail")
3545            }
3546
3547            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventInjectBarrierFail, V::Error>
3548                where
3549                    V: serde::de::MapAccess<'de>,
3550            {
3551                let mut prev_epoch__ = None;
3552                let mut cur_epoch__ = None;
3553                let mut error__ = None;
3554                while let Some(k) = map_.next_key()? {
3555                    match k {
3556                        GeneratedField::PrevEpoch => {
3557                            if prev_epoch__.is_some() {
3558                                return Err(serde::de::Error::duplicate_field("prevEpoch"));
3559                            }
3560                            prev_epoch__ = 
3561                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3562                            ;
3563                        }
3564                        GeneratedField::CurEpoch => {
3565                            if cur_epoch__.is_some() {
3566                                return Err(serde::de::Error::duplicate_field("curEpoch"));
3567                            }
3568                            cur_epoch__ = 
3569                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3570                            ;
3571                        }
3572                        GeneratedField::Error => {
3573                            if error__.is_some() {
3574                                return Err(serde::de::Error::duplicate_field("error"));
3575                            }
3576                            error__ = Some(map_.next_value()?);
3577                        }
3578                    }
3579                }
3580                Ok(event_log::EventInjectBarrierFail {
3581                    prev_epoch: prev_epoch__.unwrap_or_default(),
3582                    cur_epoch: cur_epoch__.unwrap_or_default(),
3583                    error: error__.unwrap_or_default(),
3584                })
3585            }
3586        }
3587        deserializer.deserialize_struct("meta.EventLog.EventInjectBarrierFail", FIELDS, GeneratedVisitor)
3588    }
3589}
3590impl serde::Serialize for event_log::EventMetaNodeStart {
3591    #[allow(deprecated)]
3592    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3593    where
3594        S: serde::Serializer,
3595    {
3596        use serde::ser::SerializeStruct;
3597        let mut len = 0;
3598        if !self.advertise_addr.is_empty() {
3599            len += 1;
3600        }
3601        if !self.listen_addr.is_empty() {
3602            len += 1;
3603        }
3604        if !self.opts.is_empty() {
3605            len += 1;
3606        }
3607        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventMetaNodeStart", len)?;
3608        if !self.advertise_addr.is_empty() {
3609            struct_ser.serialize_field("advertiseAddr", &self.advertise_addr)?;
3610        }
3611        if !self.listen_addr.is_empty() {
3612            struct_ser.serialize_field("listenAddr", &self.listen_addr)?;
3613        }
3614        if !self.opts.is_empty() {
3615            struct_ser.serialize_field("opts", &self.opts)?;
3616        }
3617        struct_ser.end()
3618    }
3619}
3620impl<'de> serde::Deserialize<'de> for event_log::EventMetaNodeStart {
3621    #[allow(deprecated)]
3622    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3623    where
3624        D: serde::Deserializer<'de>,
3625    {
3626        const FIELDS: &[&str] = &[
3627            "advertise_addr",
3628            "advertiseAddr",
3629            "listen_addr",
3630            "listenAddr",
3631            "opts",
3632        ];
3633
3634        #[allow(clippy::enum_variant_names)]
3635        enum GeneratedField {
3636            AdvertiseAddr,
3637            ListenAddr,
3638            Opts,
3639        }
3640        impl<'de> serde::Deserialize<'de> for GeneratedField {
3641            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3642            where
3643                D: serde::Deserializer<'de>,
3644            {
3645                struct GeneratedVisitor;
3646
3647                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3648                    type Value = GeneratedField;
3649
3650                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3651                        write!(formatter, "expected one of: {:?}", &FIELDS)
3652                    }
3653
3654                    #[allow(unused_variables)]
3655                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3656                    where
3657                        E: serde::de::Error,
3658                    {
3659                        match value {
3660                            "advertiseAddr" | "advertise_addr" => Ok(GeneratedField::AdvertiseAddr),
3661                            "listenAddr" | "listen_addr" => Ok(GeneratedField::ListenAddr),
3662                            "opts" => Ok(GeneratedField::Opts),
3663                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3664                        }
3665                    }
3666                }
3667                deserializer.deserialize_identifier(GeneratedVisitor)
3668            }
3669        }
3670        struct GeneratedVisitor;
3671        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3672            type Value = event_log::EventMetaNodeStart;
3673
3674            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3675                formatter.write_str("struct meta.EventLog.EventMetaNodeStart")
3676            }
3677
3678            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventMetaNodeStart, V::Error>
3679                where
3680                    V: serde::de::MapAccess<'de>,
3681            {
3682                let mut advertise_addr__ = None;
3683                let mut listen_addr__ = None;
3684                let mut opts__ = None;
3685                while let Some(k) = map_.next_key()? {
3686                    match k {
3687                        GeneratedField::AdvertiseAddr => {
3688                            if advertise_addr__.is_some() {
3689                                return Err(serde::de::Error::duplicate_field("advertiseAddr"));
3690                            }
3691                            advertise_addr__ = Some(map_.next_value()?);
3692                        }
3693                        GeneratedField::ListenAddr => {
3694                            if listen_addr__.is_some() {
3695                                return Err(serde::de::Error::duplicate_field("listenAddr"));
3696                            }
3697                            listen_addr__ = Some(map_.next_value()?);
3698                        }
3699                        GeneratedField::Opts => {
3700                            if opts__.is_some() {
3701                                return Err(serde::de::Error::duplicate_field("opts"));
3702                            }
3703                            opts__ = Some(map_.next_value()?);
3704                        }
3705                    }
3706                }
3707                Ok(event_log::EventMetaNodeStart {
3708                    advertise_addr: advertise_addr__.unwrap_or_default(),
3709                    listen_addr: listen_addr__.unwrap_or_default(),
3710                    opts: opts__.unwrap_or_default(),
3711                })
3712            }
3713        }
3714        deserializer.deserialize_struct("meta.EventLog.EventMetaNodeStart", FIELDS, GeneratedVisitor)
3715    }
3716}
3717impl serde::Serialize for event_log::EventRecovery {
3718    #[allow(deprecated)]
3719    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3720    where
3721        S: serde::Serializer,
3722    {
3723        use serde::ser::SerializeStruct;
3724        let mut len = 0;
3725        if self.recovery_event.is_some() {
3726            len += 1;
3727        }
3728        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery", len)?;
3729        if let Some(v) = self.recovery_event.as_ref() {
3730            match v {
3731                event_log::event_recovery::RecoveryEvent::GlobalStart(v) => {
3732                    struct_ser.serialize_field("globalStart", v)?;
3733                }
3734                event_log::event_recovery::RecoveryEvent::GlobalSuccess(v) => {
3735                    struct_ser.serialize_field("globalSuccess", v)?;
3736                }
3737                event_log::event_recovery::RecoveryEvent::GlobalFailure(v) => {
3738                    struct_ser.serialize_field("globalFailure", v)?;
3739                }
3740                event_log::event_recovery::RecoveryEvent::DatabaseStart(v) => {
3741                    struct_ser.serialize_field("databaseStart", v)?;
3742                }
3743                event_log::event_recovery::RecoveryEvent::DatabaseFailure(v) => {
3744                    struct_ser.serialize_field("databaseFailure", v)?;
3745                }
3746                event_log::event_recovery::RecoveryEvent::DatabaseSuccess(v) => {
3747                    struct_ser.serialize_field("databaseSuccess", v)?;
3748                }
3749            }
3750        }
3751        struct_ser.end()
3752    }
3753}
3754impl<'de> serde::Deserialize<'de> for event_log::EventRecovery {
3755    #[allow(deprecated)]
3756    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3757    where
3758        D: serde::Deserializer<'de>,
3759    {
3760        const FIELDS: &[&str] = &[
3761            "global_start",
3762            "globalStart",
3763            "global_success",
3764            "globalSuccess",
3765            "global_failure",
3766            "globalFailure",
3767            "database_start",
3768            "databaseStart",
3769            "database_failure",
3770            "databaseFailure",
3771            "database_success",
3772            "databaseSuccess",
3773        ];
3774
3775        #[allow(clippy::enum_variant_names)]
3776        enum GeneratedField {
3777            GlobalStart,
3778            GlobalSuccess,
3779            GlobalFailure,
3780            DatabaseStart,
3781            DatabaseFailure,
3782            DatabaseSuccess,
3783        }
3784        impl<'de> serde::Deserialize<'de> for GeneratedField {
3785            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3786            where
3787                D: serde::Deserializer<'de>,
3788            {
3789                struct GeneratedVisitor;
3790
3791                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3792                    type Value = GeneratedField;
3793
3794                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3795                        write!(formatter, "expected one of: {:?}", &FIELDS)
3796                    }
3797
3798                    #[allow(unused_variables)]
3799                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3800                    where
3801                        E: serde::de::Error,
3802                    {
3803                        match value {
3804                            "globalStart" | "global_start" => Ok(GeneratedField::GlobalStart),
3805                            "globalSuccess" | "global_success" => Ok(GeneratedField::GlobalSuccess),
3806                            "globalFailure" | "global_failure" => Ok(GeneratedField::GlobalFailure),
3807                            "databaseStart" | "database_start" => Ok(GeneratedField::DatabaseStart),
3808                            "databaseFailure" | "database_failure" => Ok(GeneratedField::DatabaseFailure),
3809                            "databaseSuccess" | "database_success" => Ok(GeneratedField::DatabaseSuccess),
3810                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3811                        }
3812                    }
3813                }
3814                deserializer.deserialize_identifier(GeneratedVisitor)
3815            }
3816        }
3817        struct GeneratedVisitor;
3818        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3819            type Value = event_log::EventRecovery;
3820
3821            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3822                formatter.write_str("struct meta.EventLog.EventRecovery")
3823            }
3824
3825            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventRecovery, V::Error>
3826                where
3827                    V: serde::de::MapAccess<'de>,
3828            {
3829                let mut recovery_event__ = None;
3830                while let Some(k) = map_.next_key()? {
3831                    match k {
3832                        GeneratedField::GlobalStart => {
3833                            if recovery_event__.is_some() {
3834                                return Err(serde::de::Error::duplicate_field("globalStart"));
3835                            }
3836                            recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalStart)
3837;
3838                        }
3839                        GeneratedField::GlobalSuccess => {
3840                            if recovery_event__.is_some() {
3841                                return Err(serde::de::Error::duplicate_field("globalSuccess"));
3842                            }
3843                            recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalSuccess)
3844;
3845                        }
3846                        GeneratedField::GlobalFailure => {
3847                            if recovery_event__.is_some() {
3848                                return Err(serde::de::Error::duplicate_field("globalFailure"));
3849                            }
3850                            recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalFailure)
3851;
3852                        }
3853                        GeneratedField::DatabaseStart => {
3854                            if recovery_event__.is_some() {
3855                                return Err(serde::de::Error::duplicate_field("databaseStart"));
3856                            }
3857                            recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseStart)
3858;
3859                        }
3860                        GeneratedField::DatabaseFailure => {
3861                            if recovery_event__.is_some() {
3862                                return Err(serde::de::Error::duplicate_field("databaseFailure"));
3863                            }
3864                            recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseFailure)
3865;
3866                        }
3867                        GeneratedField::DatabaseSuccess => {
3868                            if recovery_event__.is_some() {
3869                                return Err(serde::de::Error::duplicate_field("databaseSuccess"));
3870                            }
3871                            recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseSuccess)
3872;
3873                        }
3874                    }
3875                }
3876                Ok(event_log::EventRecovery {
3877                    recovery_event: recovery_event__,
3878                })
3879            }
3880        }
3881        deserializer.deserialize_struct("meta.EventLog.EventRecovery", FIELDS, GeneratedVisitor)
3882    }
3883}
3884impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryFailure {
3885    #[allow(deprecated)]
3886    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3887    where
3888        S: serde::Serializer,
3889    {
3890        use serde::ser::SerializeStruct;
3891        let mut len = 0;
3892        if self.database_id != 0 {
3893            len += 1;
3894        }
3895        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", len)?;
3896        if self.database_id != 0 {
3897            struct_ser.serialize_field("databaseId", &self.database_id)?;
3898        }
3899        struct_ser.end()
3900    }
3901}
3902impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryFailure {
3903    #[allow(deprecated)]
3904    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3905    where
3906        D: serde::Deserializer<'de>,
3907    {
3908        const FIELDS: &[&str] = &[
3909            "database_id",
3910            "databaseId",
3911        ];
3912
3913        #[allow(clippy::enum_variant_names)]
3914        enum GeneratedField {
3915            DatabaseId,
3916        }
3917        impl<'de> serde::Deserialize<'de> for GeneratedField {
3918            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3919            where
3920                D: serde::Deserializer<'de>,
3921            {
3922                struct GeneratedVisitor;
3923
3924                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3925                    type Value = GeneratedField;
3926
3927                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3928                        write!(formatter, "expected one of: {:?}", &FIELDS)
3929                    }
3930
3931                    #[allow(unused_variables)]
3932                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3933                    where
3934                        E: serde::de::Error,
3935                    {
3936                        match value {
3937                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
3938                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3939                        }
3940                    }
3941                }
3942                deserializer.deserialize_identifier(GeneratedVisitor)
3943            }
3944        }
3945        struct GeneratedVisitor;
3946        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3947            type Value = event_log::event_recovery::DatabaseRecoveryFailure;
3948
3949            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3950                formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryFailure")
3951            }
3952
3953            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryFailure, V::Error>
3954                where
3955                    V: serde::de::MapAccess<'de>,
3956            {
3957                let mut database_id__ = None;
3958                while let Some(k) = map_.next_key()? {
3959                    match k {
3960                        GeneratedField::DatabaseId => {
3961                            if database_id__.is_some() {
3962                                return Err(serde::de::Error::duplicate_field("databaseId"));
3963                            }
3964                            database_id__ = 
3965                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3966                            ;
3967                        }
3968                    }
3969                }
3970                Ok(event_log::event_recovery::DatabaseRecoveryFailure {
3971                    database_id: database_id__.unwrap_or_default(),
3972                })
3973            }
3974        }
3975        deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", FIELDS, GeneratedVisitor)
3976    }
3977}
3978impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryStart {
3979    #[allow(deprecated)]
3980    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3981    where
3982        S: serde::Serializer,
3983    {
3984        use serde::ser::SerializeStruct;
3985        let mut len = 0;
3986        if self.database_id != 0 {
3987            len += 1;
3988        }
3989        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", len)?;
3990        if self.database_id != 0 {
3991            struct_ser.serialize_field("databaseId", &self.database_id)?;
3992        }
3993        struct_ser.end()
3994    }
3995}
3996impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryStart {
3997    #[allow(deprecated)]
3998    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3999    where
4000        D: serde::Deserializer<'de>,
4001    {
4002        const FIELDS: &[&str] = &[
4003            "database_id",
4004            "databaseId",
4005        ];
4006
4007        #[allow(clippy::enum_variant_names)]
4008        enum GeneratedField {
4009            DatabaseId,
4010        }
4011        impl<'de> serde::Deserialize<'de> for GeneratedField {
4012            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4013            where
4014                D: serde::Deserializer<'de>,
4015            {
4016                struct GeneratedVisitor;
4017
4018                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4019                    type Value = GeneratedField;
4020
4021                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4022                        write!(formatter, "expected one of: {:?}", &FIELDS)
4023                    }
4024
4025                    #[allow(unused_variables)]
4026                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4027                    where
4028                        E: serde::de::Error,
4029                    {
4030                        match value {
4031                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4032                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4033                        }
4034                    }
4035                }
4036                deserializer.deserialize_identifier(GeneratedVisitor)
4037            }
4038        }
4039        struct GeneratedVisitor;
4040        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4041            type Value = event_log::event_recovery::DatabaseRecoveryStart;
4042
4043            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4044                formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryStart")
4045            }
4046
4047            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryStart, V::Error>
4048                where
4049                    V: serde::de::MapAccess<'de>,
4050            {
4051                let mut database_id__ = None;
4052                while let Some(k) = map_.next_key()? {
4053                    match k {
4054                        GeneratedField::DatabaseId => {
4055                            if database_id__.is_some() {
4056                                return Err(serde::de::Error::duplicate_field("databaseId"));
4057                            }
4058                            database_id__ = 
4059                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4060                            ;
4061                        }
4062                    }
4063                }
4064                Ok(event_log::event_recovery::DatabaseRecoveryStart {
4065                    database_id: database_id__.unwrap_or_default(),
4066                })
4067            }
4068        }
4069        deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", FIELDS, GeneratedVisitor)
4070    }
4071}
4072impl serde::Serialize for event_log::event_recovery::DatabaseRecoverySuccess {
4073    #[allow(deprecated)]
4074    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4075    where
4076        S: serde::Serializer,
4077    {
4078        use serde::ser::SerializeStruct;
4079        let mut len = 0;
4080        if self.database_id != 0 {
4081            len += 1;
4082        }
4083        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", len)?;
4084        if self.database_id != 0 {
4085            struct_ser.serialize_field("databaseId", &self.database_id)?;
4086        }
4087        struct_ser.end()
4088    }
4089}
4090impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoverySuccess {
4091    #[allow(deprecated)]
4092    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4093    where
4094        D: serde::Deserializer<'de>,
4095    {
4096        const FIELDS: &[&str] = &[
4097            "database_id",
4098            "databaseId",
4099        ];
4100
4101        #[allow(clippy::enum_variant_names)]
4102        enum GeneratedField {
4103            DatabaseId,
4104        }
4105        impl<'de> serde::Deserialize<'de> for GeneratedField {
4106            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4107            where
4108                D: serde::Deserializer<'de>,
4109            {
4110                struct GeneratedVisitor;
4111
4112                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4113                    type Value = GeneratedField;
4114
4115                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4116                        write!(formatter, "expected one of: {:?}", &FIELDS)
4117                    }
4118
4119                    #[allow(unused_variables)]
4120                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4121                    where
4122                        E: serde::de::Error,
4123                    {
4124                        match value {
4125                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4126                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4127                        }
4128                    }
4129                }
4130                deserializer.deserialize_identifier(GeneratedVisitor)
4131            }
4132        }
4133        struct GeneratedVisitor;
4134        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4135            type Value = event_log::event_recovery::DatabaseRecoverySuccess;
4136
4137            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4138                formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoverySuccess")
4139            }
4140
4141            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoverySuccess, V::Error>
4142                where
4143                    V: serde::de::MapAccess<'de>,
4144            {
4145                let mut database_id__ = None;
4146                while let Some(k) = map_.next_key()? {
4147                    match k {
4148                        GeneratedField::DatabaseId => {
4149                            if database_id__.is_some() {
4150                                return Err(serde::de::Error::duplicate_field("databaseId"));
4151                            }
4152                            database_id__ = 
4153                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4154                            ;
4155                        }
4156                    }
4157                }
4158                Ok(event_log::event_recovery::DatabaseRecoverySuccess {
4159                    database_id: database_id__.unwrap_or_default(),
4160                })
4161            }
4162        }
4163        deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", FIELDS, GeneratedVisitor)
4164    }
4165}
4166impl serde::Serialize for event_log::event_recovery::GlobalRecoveryFailure {
4167    #[allow(deprecated)]
4168    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4169    where
4170        S: serde::Serializer,
4171    {
4172        use serde::ser::SerializeStruct;
4173        let mut len = 0;
4174        if !self.reason.is_empty() {
4175            len += 1;
4176        }
4177        if !self.error.is_empty() {
4178            len += 1;
4179        }
4180        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", len)?;
4181        if !self.reason.is_empty() {
4182            struct_ser.serialize_field("reason", &self.reason)?;
4183        }
4184        if !self.error.is_empty() {
4185            struct_ser.serialize_field("error", &self.error)?;
4186        }
4187        struct_ser.end()
4188    }
4189}
4190impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryFailure {
4191    #[allow(deprecated)]
4192    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4193    where
4194        D: serde::Deserializer<'de>,
4195    {
4196        const FIELDS: &[&str] = &[
4197            "reason",
4198            "error",
4199        ];
4200
4201        #[allow(clippy::enum_variant_names)]
4202        enum GeneratedField {
4203            Reason,
4204            Error,
4205        }
4206        impl<'de> serde::Deserialize<'de> for GeneratedField {
4207            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4208            where
4209                D: serde::Deserializer<'de>,
4210            {
4211                struct GeneratedVisitor;
4212
4213                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4214                    type Value = GeneratedField;
4215
4216                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4217                        write!(formatter, "expected one of: {:?}", &FIELDS)
4218                    }
4219
4220                    #[allow(unused_variables)]
4221                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4222                    where
4223                        E: serde::de::Error,
4224                    {
4225                        match value {
4226                            "reason" => Ok(GeneratedField::Reason),
4227                            "error" => Ok(GeneratedField::Error),
4228                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4229                        }
4230                    }
4231                }
4232                deserializer.deserialize_identifier(GeneratedVisitor)
4233            }
4234        }
4235        struct GeneratedVisitor;
4236        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4237            type Value = event_log::event_recovery::GlobalRecoveryFailure;
4238
4239            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4240                formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryFailure")
4241            }
4242
4243            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryFailure, V::Error>
4244                where
4245                    V: serde::de::MapAccess<'de>,
4246            {
4247                let mut reason__ = None;
4248                let mut error__ = None;
4249                while let Some(k) = map_.next_key()? {
4250                    match k {
4251                        GeneratedField::Reason => {
4252                            if reason__.is_some() {
4253                                return Err(serde::de::Error::duplicate_field("reason"));
4254                            }
4255                            reason__ = Some(map_.next_value()?);
4256                        }
4257                        GeneratedField::Error => {
4258                            if error__.is_some() {
4259                                return Err(serde::de::Error::duplicate_field("error"));
4260                            }
4261                            error__ = Some(map_.next_value()?);
4262                        }
4263                    }
4264                }
4265                Ok(event_log::event_recovery::GlobalRecoveryFailure {
4266                    reason: reason__.unwrap_or_default(),
4267                    error: error__.unwrap_or_default(),
4268                })
4269            }
4270        }
4271        deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", FIELDS, GeneratedVisitor)
4272    }
4273}
4274impl serde::Serialize for event_log::event_recovery::GlobalRecoveryStart {
4275    #[allow(deprecated)]
4276    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4277    where
4278        S: serde::Serializer,
4279    {
4280        use serde::ser::SerializeStruct;
4281        let mut len = 0;
4282        if !self.reason.is_empty() {
4283            len += 1;
4284        }
4285        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", len)?;
4286        if !self.reason.is_empty() {
4287            struct_ser.serialize_field("reason", &self.reason)?;
4288        }
4289        struct_ser.end()
4290    }
4291}
4292impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryStart {
4293    #[allow(deprecated)]
4294    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4295    where
4296        D: serde::Deserializer<'de>,
4297    {
4298        const FIELDS: &[&str] = &[
4299            "reason",
4300        ];
4301
4302        #[allow(clippy::enum_variant_names)]
4303        enum GeneratedField {
4304            Reason,
4305        }
4306        impl<'de> serde::Deserialize<'de> for GeneratedField {
4307            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4308            where
4309                D: serde::Deserializer<'de>,
4310            {
4311                struct GeneratedVisitor;
4312
4313                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4314                    type Value = GeneratedField;
4315
4316                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4317                        write!(formatter, "expected one of: {:?}", &FIELDS)
4318                    }
4319
4320                    #[allow(unused_variables)]
4321                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4322                    where
4323                        E: serde::de::Error,
4324                    {
4325                        match value {
4326                            "reason" => Ok(GeneratedField::Reason),
4327                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4328                        }
4329                    }
4330                }
4331                deserializer.deserialize_identifier(GeneratedVisitor)
4332            }
4333        }
4334        struct GeneratedVisitor;
4335        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4336            type Value = event_log::event_recovery::GlobalRecoveryStart;
4337
4338            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4339                formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryStart")
4340            }
4341
4342            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryStart, V::Error>
4343                where
4344                    V: serde::de::MapAccess<'de>,
4345            {
4346                let mut reason__ = None;
4347                while let Some(k) = map_.next_key()? {
4348                    match k {
4349                        GeneratedField::Reason => {
4350                            if reason__.is_some() {
4351                                return Err(serde::de::Error::duplicate_field("reason"));
4352                            }
4353                            reason__ = Some(map_.next_value()?);
4354                        }
4355                    }
4356                }
4357                Ok(event_log::event_recovery::GlobalRecoveryStart {
4358                    reason: reason__.unwrap_or_default(),
4359                })
4360            }
4361        }
4362        deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", FIELDS, GeneratedVisitor)
4363    }
4364}
4365impl serde::Serialize for event_log::event_recovery::GlobalRecoverySuccess {
4366    #[allow(deprecated)]
4367    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4368    where
4369        S: serde::Serializer,
4370    {
4371        use serde::ser::SerializeStruct;
4372        let mut len = 0;
4373        if !self.reason.is_empty() {
4374            len += 1;
4375        }
4376        if self.duration_secs != 0. {
4377            len += 1;
4378        }
4379        if !self.running_database_ids.is_empty() {
4380            len += 1;
4381        }
4382        if !self.recovering_database_ids.is_empty() {
4383            len += 1;
4384        }
4385        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", len)?;
4386        if !self.reason.is_empty() {
4387            struct_ser.serialize_field("reason", &self.reason)?;
4388        }
4389        if self.duration_secs != 0. {
4390            struct_ser.serialize_field("durationSecs", &self.duration_secs)?;
4391        }
4392        if !self.running_database_ids.is_empty() {
4393            struct_ser.serialize_field("runningDatabaseIds", &self.running_database_ids)?;
4394        }
4395        if !self.recovering_database_ids.is_empty() {
4396            struct_ser.serialize_field("recoveringDatabaseIds", &self.recovering_database_ids)?;
4397        }
4398        struct_ser.end()
4399    }
4400}
4401impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoverySuccess {
4402    #[allow(deprecated)]
4403    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4404    where
4405        D: serde::Deserializer<'de>,
4406    {
4407        const FIELDS: &[&str] = &[
4408            "reason",
4409            "duration_secs",
4410            "durationSecs",
4411            "running_database_ids",
4412            "runningDatabaseIds",
4413            "recovering_database_ids",
4414            "recoveringDatabaseIds",
4415        ];
4416
4417        #[allow(clippy::enum_variant_names)]
4418        enum GeneratedField {
4419            Reason,
4420            DurationSecs,
4421            RunningDatabaseIds,
4422            RecoveringDatabaseIds,
4423        }
4424        impl<'de> serde::Deserialize<'de> for GeneratedField {
4425            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4426            where
4427                D: serde::Deserializer<'de>,
4428            {
4429                struct GeneratedVisitor;
4430
4431                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4432                    type Value = GeneratedField;
4433
4434                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4435                        write!(formatter, "expected one of: {:?}", &FIELDS)
4436                    }
4437
4438                    #[allow(unused_variables)]
4439                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4440                    where
4441                        E: serde::de::Error,
4442                    {
4443                        match value {
4444                            "reason" => Ok(GeneratedField::Reason),
4445                            "durationSecs" | "duration_secs" => Ok(GeneratedField::DurationSecs),
4446                            "runningDatabaseIds" | "running_database_ids" => Ok(GeneratedField::RunningDatabaseIds),
4447                            "recoveringDatabaseIds" | "recovering_database_ids" => Ok(GeneratedField::RecoveringDatabaseIds),
4448                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4449                        }
4450                    }
4451                }
4452                deserializer.deserialize_identifier(GeneratedVisitor)
4453            }
4454        }
4455        struct GeneratedVisitor;
4456        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4457            type Value = event_log::event_recovery::GlobalRecoverySuccess;
4458
4459            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4460                formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoverySuccess")
4461            }
4462
4463            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoverySuccess, V::Error>
4464                where
4465                    V: serde::de::MapAccess<'de>,
4466            {
4467                let mut reason__ = None;
4468                let mut duration_secs__ = None;
4469                let mut running_database_ids__ = None;
4470                let mut recovering_database_ids__ = None;
4471                while let Some(k) = map_.next_key()? {
4472                    match k {
4473                        GeneratedField::Reason => {
4474                            if reason__.is_some() {
4475                                return Err(serde::de::Error::duplicate_field("reason"));
4476                            }
4477                            reason__ = Some(map_.next_value()?);
4478                        }
4479                        GeneratedField::DurationSecs => {
4480                            if duration_secs__.is_some() {
4481                                return Err(serde::de::Error::duplicate_field("durationSecs"));
4482                            }
4483                            duration_secs__ = 
4484                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4485                            ;
4486                        }
4487                        GeneratedField::RunningDatabaseIds => {
4488                            if running_database_ids__.is_some() {
4489                                return Err(serde::de::Error::duplicate_field("runningDatabaseIds"));
4490                            }
4491                            running_database_ids__ = 
4492                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4493                                    .into_iter().map(|x| x.0).collect())
4494                            ;
4495                        }
4496                        GeneratedField::RecoveringDatabaseIds => {
4497                            if recovering_database_ids__.is_some() {
4498                                return Err(serde::de::Error::duplicate_field("recoveringDatabaseIds"));
4499                            }
4500                            recovering_database_ids__ = 
4501                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4502                                    .into_iter().map(|x| x.0).collect())
4503                            ;
4504                        }
4505                    }
4506                }
4507                Ok(event_log::event_recovery::GlobalRecoverySuccess {
4508                    reason: reason__.unwrap_or_default(),
4509                    duration_secs: duration_secs__.unwrap_or_default(),
4510                    running_database_ids: running_database_ids__.unwrap_or_default(),
4511                    recovering_database_ids: recovering_database_ids__.unwrap_or_default(),
4512                })
4513            }
4514        }
4515        deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", FIELDS, GeneratedVisitor)
4516    }
4517}
4518impl serde::Serialize for event_log::EventSinkFail {
4519    #[allow(deprecated)]
4520    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4521    where
4522        S: serde::Serializer,
4523    {
4524        use serde::ser::SerializeStruct;
4525        let mut len = 0;
4526        if self.sink_id != 0 {
4527            len += 1;
4528        }
4529        if !self.sink_name.is_empty() {
4530            len += 1;
4531        }
4532        if !self.connector.is_empty() {
4533            len += 1;
4534        }
4535        if !self.error.is_empty() {
4536            len += 1;
4537        }
4538        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventSinkFail", len)?;
4539        if self.sink_id != 0 {
4540            struct_ser.serialize_field("sinkId", &self.sink_id)?;
4541        }
4542        if !self.sink_name.is_empty() {
4543            struct_ser.serialize_field("sinkName", &self.sink_name)?;
4544        }
4545        if !self.connector.is_empty() {
4546            struct_ser.serialize_field("connector", &self.connector)?;
4547        }
4548        if !self.error.is_empty() {
4549            struct_ser.serialize_field("error", &self.error)?;
4550        }
4551        struct_ser.end()
4552    }
4553}
4554impl<'de> serde::Deserialize<'de> for event_log::EventSinkFail {
4555    #[allow(deprecated)]
4556    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4557    where
4558        D: serde::Deserializer<'de>,
4559    {
4560        const FIELDS: &[&str] = &[
4561            "sink_id",
4562            "sinkId",
4563            "sink_name",
4564            "sinkName",
4565            "connector",
4566            "error",
4567        ];
4568
4569        #[allow(clippy::enum_variant_names)]
4570        enum GeneratedField {
4571            SinkId,
4572            SinkName,
4573            Connector,
4574            Error,
4575        }
4576        impl<'de> serde::Deserialize<'de> for GeneratedField {
4577            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4578            where
4579                D: serde::Deserializer<'de>,
4580            {
4581                struct GeneratedVisitor;
4582
4583                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4584                    type Value = GeneratedField;
4585
4586                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4587                        write!(formatter, "expected one of: {:?}", &FIELDS)
4588                    }
4589
4590                    #[allow(unused_variables)]
4591                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4592                    where
4593                        E: serde::de::Error,
4594                    {
4595                        match value {
4596                            "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
4597                            "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
4598                            "connector" => Ok(GeneratedField::Connector),
4599                            "error" => Ok(GeneratedField::Error),
4600                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4601                        }
4602                    }
4603                }
4604                deserializer.deserialize_identifier(GeneratedVisitor)
4605            }
4606        }
4607        struct GeneratedVisitor;
4608        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4609            type Value = event_log::EventSinkFail;
4610
4611            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4612                formatter.write_str("struct meta.EventLog.EventSinkFail")
4613            }
4614
4615            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventSinkFail, V::Error>
4616                where
4617                    V: serde::de::MapAccess<'de>,
4618            {
4619                let mut sink_id__ = None;
4620                let mut sink_name__ = None;
4621                let mut connector__ = None;
4622                let mut error__ = None;
4623                while let Some(k) = map_.next_key()? {
4624                    match k {
4625                        GeneratedField::SinkId => {
4626                            if sink_id__.is_some() {
4627                                return Err(serde::de::Error::duplicate_field("sinkId"));
4628                            }
4629                            sink_id__ = 
4630                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4631                            ;
4632                        }
4633                        GeneratedField::SinkName => {
4634                            if sink_name__.is_some() {
4635                                return Err(serde::de::Error::duplicate_field("sinkName"));
4636                            }
4637                            sink_name__ = Some(map_.next_value()?);
4638                        }
4639                        GeneratedField::Connector => {
4640                            if connector__.is_some() {
4641                                return Err(serde::de::Error::duplicate_field("connector"));
4642                            }
4643                            connector__ = Some(map_.next_value()?);
4644                        }
4645                        GeneratedField::Error => {
4646                            if error__.is_some() {
4647                                return Err(serde::de::Error::duplicate_field("error"));
4648                            }
4649                            error__ = Some(map_.next_value()?);
4650                        }
4651                    }
4652                }
4653                Ok(event_log::EventSinkFail {
4654                    sink_id: sink_id__.unwrap_or_default(),
4655                    sink_name: sink_name__.unwrap_or_default(),
4656                    connector: connector__.unwrap_or_default(),
4657                    error: error__.unwrap_or_default(),
4658                })
4659            }
4660        }
4661        deserializer.deserialize_struct("meta.EventLog.EventSinkFail", FIELDS, GeneratedVisitor)
4662    }
4663}
4664impl serde::Serialize for event_log::EventWorkerNodePanic {
4665    #[allow(deprecated)]
4666    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4667    where
4668        S: serde::Serializer,
4669    {
4670        use serde::ser::SerializeStruct;
4671        let mut len = 0;
4672        if self.worker_id != 0 {
4673            len += 1;
4674        }
4675        if self.worker_type != 0 {
4676            len += 1;
4677        }
4678        if self.host_addr.is_some() {
4679            len += 1;
4680        }
4681        if !self.panic_info.is_empty() {
4682            len += 1;
4683        }
4684        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventWorkerNodePanic", len)?;
4685        if self.worker_id != 0 {
4686            struct_ser.serialize_field("workerId", &self.worker_id)?;
4687        }
4688        if self.worker_type != 0 {
4689            let v = super::common::WorkerType::try_from(self.worker_type)
4690                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
4691            struct_ser.serialize_field("workerType", &v)?;
4692        }
4693        if let Some(v) = self.host_addr.as_ref() {
4694            struct_ser.serialize_field("hostAddr", v)?;
4695        }
4696        if !self.panic_info.is_empty() {
4697            struct_ser.serialize_field("panicInfo", &self.panic_info)?;
4698        }
4699        struct_ser.end()
4700    }
4701}
4702impl<'de> serde::Deserialize<'de> for event_log::EventWorkerNodePanic {
4703    #[allow(deprecated)]
4704    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4705    where
4706        D: serde::Deserializer<'de>,
4707    {
4708        const FIELDS: &[&str] = &[
4709            "worker_id",
4710            "workerId",
4711            "worker_type",
4712            "workerType",
4713            "host_addr",
4714            "hostAddr",
4715            "panic_info",
4716            "panicInfo",
4717        ];
4718
4719        #[allow(clippy::enum_variant_names)]
4720        enum GeneratedField {
4721            WorkerId,
4722            WorkerType,
4723            HostAddr,
4724            PanicInfo,
4725        }
4726        impl<'de> serde::Deserialize<'de> for GeneratedField {
4727            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4728            where
4729                D: serde::Deserializer<'de>,
4730            {
4731                struct GeneratedVisitor;
4732
4733                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4734                    type Value = GeneratedField;
4735
4736                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4737                        write!(formatter, "expected one of: {:?}", &FIELDS)
4738                    }
4739
4740                    #[allow(unused_variables)]
4741                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4742                    where
4743                        E: serde::de::Error,
4744                    {
4745                        match value {
4746                            "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
4747                            "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
4748                            "hostAddr" | "host_addr" => Ok(GeneratedField::HostAddr),
4749                            "panicInfo" | "panic_info" => Ok(GeneratedField::PanicInfo),
4750                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4751                        }
4752                    }
4753                }
4754                deserializer.deserialize_identifier(GeneratedVisitor)
4755            }
4756        }
4757        struct GeneratedVisitor;
4758        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4759            type Value = event_log::EventWorkerNodePanic;
4760
4761            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4762                formatter.write_str("struct meta.EventLog.EventWorkerNodePanic")
4763            }
4764
4765            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventWorkerNodePanic, V::Error>
4766                where
4767                    V: serde::de::MapAccess<'de>,
4768            {
4769                let mut worker_id__ = None;
4770                let mut worker_type__ = None;
4771                let mut host_addr__ = None;
4772                let mut panic_info__ = None;
4773                while let Some(k) = map_.next_key()? {
4774                    match k {
4775                        GeneratedField::WorkerId => {
4776                            if worker_id__.is_some() {
4777                                return Err(serde::de::Error::duplicate_field("workerId"));
4778                            }
4779                            worker_id__ = 
4780                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4781                            ;
4782                        }
4783                        GeneratedField::WorkerType => {
4784                            if worker_type__.is_some() {
4785                                return Err(serde::de::Error::duplicate_field("workerType"));
4786                            }
4787                            worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
4788                        }
4789                        GeneratedField::HostAddr => {
4790                            if host_addr__.is_some() {
4791                                return Err(serde::de::Error::duplicate_field("hostAddr"));
4792                            }
4793                            host_addr__ = map_.next_value()?;
4794                        }
4795                        GeneratedField::PanicInfo => {
4796                            if panic_info__.is_some() {
4797                                return Err(serde::de::Error::duplicate_field("panicInfo"));
4798                            }
4799                            panic_info__ = Some(map_.next_value()?);
4800                        }
4801                    }
4802                }
4803                Ok(event_log::EventWorkerNodePanic {
4804                    worker_id: worker_id__.unwrap_or_default(),
4805                    worker_type: worker_type__.unwrap_or_default(),
4806                    host_addr: host_addr__,
4807                    panic_info: panic_info__.unwrap_or_default(),
4808                })
4809            }
4810        }
4811        deserializer.deserialize_struct("meta.EventLog.EventWorkerNodePanic", FIELDS, GeneratedVisitor)
4812    }
4813}
4814impl serde::Serialize for FlushRequest {
4815    #[allow(deprecated)]
4816    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4817    where
4818        S: serde::Serializer,
4819    {
4820        use serde::ser::SerializeStruct;
4821        let mut len = 0;
4822        if self.database_id != 0 {
4823            len += 1;
4824        }
4825        let mut struct_ser = serializer.serialize_struct("meta.FlushRequest", len)?;
4826        if self.database_id != 0 {
4827            struct_ser.serialize_field("databaseId", &self.database_id)?;
4828        }
4829        struct_ser.end()
4830    }
4831}
4832impl<'de> serde::Deserialize<'de> for FlushRequest {
4833    #[allow(deprecated)]
4834    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4835    where
4836        D: serde::Deserializer<'de>,
4837    {
4838        const FIELDS: &[&str] = &[
4839            "database_id",
4840            "databaseId",
4841        ];
4842
4843        #[allow(clippy::enum_variant_names)]
4844        enum GeneratedField {
4845            DatabaseId,
4846        }
4847        impl<'de> serde::Deserialize<'de> for GeneratedField {
4848            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4849            where
4850                D: serde::Deserializer<'de>,
4851            {
4852                struct GeneratedVisitor;
4853
4854                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4855                    type Value = GeneratedField;
4856
4857                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4858                        write!(formatter, "expected one of: {:?}", &FIELDS)
4859                    }
4860
4861                    #[allow(unused_variables)]
4862                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4863                    where
4864                        E: serde::de::Error,
4865                    {
4866                        match value {
4867                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4868                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4869                        }
4870                    }
4871                }
4872                deserializer.deserialize_identifier(GeneratedVisitor)
4873            }
4874        }
4875        struct GeneratedVisitor;
4876        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4877            type Value = FlushRequest;
4878
4879            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4880                formatter.write_str("struct meta.FlushRequest")
4881            }
4882
4883            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushRequest, V::Error>
4884                where
4885                    V: serde::de::MapAccess<'de>,
4886            {
4887                let mut database_id__ = None;
4888                while let Some(k) = map_.next_key()? {
4889                    match k {
4890                        GeneratedField::DatabaseId => {
4891                            if database_id__.is_some() {
4892                                return Err(serde::de::Error::duplicate_field("databaseId"));
4893                            }
4894                            database_id__ = 
4895                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4896                            ;
4897                        }
4898                    }
4899                }
4900                Ok(FlushRequest {
4901                    database_id: database_id__.unwrap_or_default(),
4902                })
4903            }
4904        }
4905        deserializer.deserialize_struct("meta.FlushRequest", FIELDS, GeneratedVisitor)
4906    }
4907}
4908impl serde::Serialize for FlushResponse {
4909    #[allow(deprecated)]
4910    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4911    where
4912        S: serde::Serializer,
4913    {
4914        use serde::ser::SerializeStruct;
4915        let mut len = 0;
4916        if self.status.is_some() {
4917            len += 1;
4918        }
4919        if self.hummock_version_id != 0 {
4920            len += 1;
4921        }
4922        let mut struct_ser = serializer.serialize_struct("meta.FlushResponse", len)?;
4923        if let Some(v) = self.status.as_ref() {
4924            struct_ser.serialize_field("status", v)?;
4925        }
4926        if self.hummock_version_id != 0 {
4927            #[allow(clippy::needless_borrow)]
4928            #[allow(clippy::needless_borrows_for_generic_args)]
4929            struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
4930        }
4931        struct_ser.end()
4932    }
4933}
4934impl<'de> serde::Deserialize<'de> for FlushResponse {
4935    #[allow(deprecated)]
4936    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4937    where
4938        D: serde::Deserializer<'de>,
4939    {
4940        const FIELDS: &[&str] = &[
4941            "status",
4942            "hummock_version_id",
4943            "hummockVersionId",
4944        ];
4945
4946        #[allow(clippy::enum_variant_names)]
4947        enum GeneratedField {
4948            Status,
4949            HummockVersionId,
4950        }
4951        impl<'de> serde::Deserialize<'de> for GeneratedField {
4952            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4953            where
4954                D: serde::Deserializer<'de>,
4955            {
4956                struct GeneratedVisitor;
4957
4958                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4959                    type Value = GeneratedField;
4960
4961                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4962                        write!(formatter, "expected one of: {:?}", &FIELDS)
4963                    }
4964
4965                    #[allow(unused_variables)]
4966                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4967                    where
4968                        E: serde::de::Error,
4969                    {
4970                        match value {
4971                            "status" => Ok(GeneratedField::Status),
4972                            "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
4973                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4974                        }
4975                    }
4976                }
4977                deserializer.deserialize_identifier(GeneratedVisitor)
4978            }
4979        }
4980        struct GeneratedVisitor;
4981        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4982            type Value = FlushResponse;
4983
4984            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4985                formatter.write_str("struct meta.FlushResponse")
4986            }
4987
4988            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushResponse, V::Error>
4989                where
4990                    V: serde::de::MapAccess<'de>,
4991            {
4992                let mut status__ = None;
4993                let mut hummock_version_id__ = None;
4994                while let Some(k) = map_.next_key()? {
4995                    match k {
4996                        GeneratedField::Status => {
4997                            if status__.is_some() {
4998                                return Err(serde::de::Error::duplicate_field("status"));
4999                            }
5000                            status__ = map_.next_value()?;
5001                        }
5002                        GeneratedField::HummockVersionId => {
5003                            if hummock_version_id__.is_some() {
5004                                return Err(serde::de::Error::duplicate_field("hummockVersionId"));
5005                            }
5006                            hummock_version_id__ = 
5007                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5008                            ;
5009                        }
5010                    }
5011                }
5012                Ok(FlushResponse {
5013                    status: status__,
5014                    hummock_version_id: hummock_version_id__.unwrap_or_default(),
5015                })
5016            }
5017        }
5018        deserializer.deserialize_struct("meta.FlushResponse", FIELDS, GeneratedVisitor)
5019    }
5020}
5021impl serde::Serialize for FragmentDistribution {
5022    #[allow(deprecated)]
5023    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5024    where
5025        S: serde::Serializer,
5026    {
5027        use serde::ser::SerializeStruct;
5028        let mut len = 0;
5029        if self.fragment_id != 0 {
5030            len += 1;
5031        }
5032        if self.table_id != 0 {
5033            len += 1;
5034        }
5035        if self.distribution_type != 0 {
5036            len += 1;
5037        }
5038        if !self.state_table_ids.is_empty() {
5039            len += 1;
5040        }
5041        if !self.upstream_fragment_ids.is_empty() {
5042            len += 1;
5043        }
5044        if self.fragment_type_mask != 0 {
5045            len += 1;
5046        }
5047        if self.parallelism != 0 {
5048            len += 1;
5049        }
5050        if self.vnode_count != 0 {
5051            len += 1;
5052        }
5053        if self.node.is_some() {
5054            len += 1;
5055        }
5056        let mut struct_ser = serializer.serialize_struct("meta.FragmentDistribution", len)?;
5057        if self.fragment_id != 0 {
5058            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5059        }
5060        if self.table_id != 0 {
5061            struct_ser.serialize_field("tableId", &self.table_id)?;
5062        }
5063        if self.distribution_type != 0 {
5064            let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
5065                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
5066            struct_ser.serialize_field("distributionType", &v)?;
5067        }
5068        if !self.state_table_ids.is_empty() {
5069            struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
5070        }
5071        if !self.upstream_fragment_ids.is_empty() {
5072            struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
5073        }
5074        if self.fragment_type_mask != 0 {
5075            struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
5076        }
5077        if self.parallelism != 0 {
5078            struct_ser.serialize_field("parallelism", &self.parallelism)?;
5079        }
5080        if self.vnode_count != 0 {
5081            struct_ser.serialize_field("vnodeCount", &self.vnode_count)?;
5082        }
5083        if let Some(v) = self.node.as_ref() {
5084            struct_ser.serialize_field("node", v)?;
5085        }
5086        struct_ser.end()
5087    }
5088}
5089impl<'de> serde::Deserialize<'de> for FragmentDistribution {
5090    #[allow(deprecated)]
5091    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5092    where
5093        D: serde::Deserializer<'de>,
5094    {
5095        const FIELDS: &[&str] = &[
5096            "fragment_id",
5097            "fragmentId",
5098            "table_id",
5099            "tableId",
5100            "distribution_type",
5101            "distributionType",
5102            "state_table_ids",
5103            "stateTableIds",
5104            "upstream_fragment_ids",
5105            "upstreamFragmentIds",
5106            "fragment_type_mask",
5107            "fragmentTypeMask",
5108            "parallelism",
5109            "vnode_count",
5110            "vnodeCount",
5111            "node",
5112        ];
5113
5114        #[allow(clippy::enum_variant_names)]
5115        enum GeneratedField {
5116            FragmentId,
5117            TableId,
5118            DistributionType,
5119            StateTableIds,
5120            UpstreamFragmentIds,
5121            FragmentTypeMask,
5122            Parallelism,
5123            VnodeCount,
5124            Node,
5125        }
5126        impl<'de> serde::Deserialize<'de> for GeneratedField {
5127            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5128            where
5129                D: serde::Deserializer<'de>,
5130            {
5131                struct GeneratedVisitor;
5132
5133                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5134                    type Value = GeneratedField;
5135
5136                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5137                        write!(formatter, "expected one of: {:?}", &FIELDS)
5138                    }
5139
5140                    #[allow(unused_variables)]
5141                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5142                    where
5143                        E: serde::de::Error,
5144                    {
5145                        match value {
5146                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5147                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
5148                            "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
5149                            "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
5150                            "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
5151                            "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
5152                            "parallelism" => Ok(GeneratedField::Parallelism),
5153                            "vnodeCount" | "vnode_count" => Ok(GeneratedField::VnodeCount),
5154                            "node" => Ok(GeneratedField::Node),
5155                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5156                        }
5157                    }
5158                }
5159                deserializer.deserialize_identifier(GeneratedVisitor)
5160            }
5161        }
5162        struct GeneratedVisitor;
5163        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5164            type Value = FragmentDistribution;
5165
5166            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5167                formatter.write_str("struct meta.FragmentDistribution")
5168            }
5169
5170            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentDistribution, V::Error>
5171                where
5172                    V: serde::de::MapAccess<'de>,
5173            {
5174                let mut fragment_id__ = None;
5175                let mut table_id__ = None;
5176                let mut distribution_type__ = None;
5177                let mut state_table_ids__ = None;
5178                let mut upstream_fragment_ids__ = None;
5179                let mut fragment_type_mask__ = None;
5180                let mut parallelism__ = None;
5181                let mut vnode_count__ = None;
5182                let mut node__ = None;
5183                while let Some(k) = map_.next_key()? {
5184                    match k {
5185                        GeneratedField::FragmentId => {
5186                            if fragment_id__.is_some() {
5187                                return Err(serde::de::Error::duplicate_field("fragmentId"));
5188                            }
5189                            fragment_id__ = 
5190                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5191                            ;
5192                        }
5193                        GeneratedField::TableId => {
5194                            if table_id__.is_some() {
5195                                return Err(serde::de::Error::duplicate_field("tableId"));
5196                            }
5197                            table_id__ = 
5198                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5199                            ;
5200                        }
5201                        GeneratedField::DistributionType => {
5202                            if distribution_type__.is_some() {
5203                                return Err(serde::de::Error::duplicate_field("distributionType"));
5204                            }
5205                            distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
5206                        }
5207                        GeneratedField::StateTableIds => {
5208                            if state_table_ids__.is_some() {
5209                                return Err(serde::de::Error::duplicate_field("stateTableIds"));
5210                            }
5211                            state_table_ids__ = 
5212                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5213                                    .into_iter().map(|x| x.0).collect())
5214                            ;
5215                        }
5216                        GeneratedField::UpstreamFragmentIds => {
5217                            if upstream_fragment_ids__.is_some() {
5218                                return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
5219                            }
5220                            upstream_fragment_ids__ = 
5221                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5222                                    .into_iter().map(|x| x.0).collect())
5223                            ;
5224                        }
5225                        GeneratedField::FragmentTypeMask => {
5226                            if fragment_type_mask__.is_some() {
5227                                return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
5228                            }
5229                            fragment_type_mask__ = 
5230                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5231                            ;
5232                        }
5233                        GeneratedField::Parallelism => {
5234                            if parallelism__.is_some() {
5235                                return Err(serde::de::Error::duplicate_field("parallelism"));
5236                            }
5237                            parallelism__ = 
5238                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5239                            ;
5240                        }
5241                        GeneratedField::VnodeCount => {
5242                            if vnode_count__.is_some() {
5243                                return Err(serde::de::Error::duplicate_field("vnodeCount"));
5244                            }
5245                            vnode_count__ = 
5246                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5247                            ;
5248                        }
5249                        GeneratedField::Node => {
5250                            if node__.is_some() {
5251                                return Err(serde::de::Error::duplicate_field("node"));
5252                            }
5253                            node__ = map_.next_value()?;
5254                        }
5255                    }
5256                }
5257                Ok(FragmentDistribution {
5258                    fragment_id: fragment_id__.unwrap_or_default(),
5259                    table_id: table_id__.unwrap_or_default(),
5260                    distribution_type: distribution_type__.unwrap_or_default(),
5261                    state_table_ids: state_table_ids__.unwrap_or_default(),
5262                    upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
5263                    fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
5264                    parallelism: parallelism__.unwrap_or_default(),
5265                    vnode_count: vnode_count__.unwrap_or_default(),
5266                    node: node__,
5267                })
5268            }
5269        }
5270        deserializer.deserialize_struct("meta.FragmentDistribution", FIELDS, GeneratedVisitor)
5271    }
5272}
5273impl serde::Serialize for FragmentIdToActorIdMap {
5274    #[allow(deprecated)]
5275    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5276    where
5277        S: serde::Serializer,
5278    {
5279        use serde::ser::SerializeStruct;
5280        let mut len = 0;
5281        if !self.map.is_empty() {
5282            len += 1;
5283        }
5284        let mut struct_ser = serializer.serialize_struct("meta.FragmentIdToActorIdMap", len)?;
5285        if !self.map.is_empty() {
5286            struct_ser.serialize_field("map", &self.map)?;
5287        }
5288        struct_ser.end()
5289    }
5290}
5291impl<'de> serde::Deserialize<'de> for FragmentIdToActorIdMap {
5292    #[allow(deprecated)]
5293    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5294    where
5295        D: serde::Deserializer<'de>,
5296    {
5297        const FIELDS: &[&str] = &[
5298            "map",
5299        ];
5300
5301        #[allow(clippy::enum_variant_names)]
5302        enum GeneratedField {
5303            Map,
5304        }
5305        impl<'de> serde::Deserialize<'de> for GeneratedField {
5306            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5307            where
5308                D: serde::Deserializer<'de>,
5309            {
5310                struct GeneratedVisitor;
5311
5312                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5313                    type Value = GeneratedField;
5314
5315                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5316                        write!(formatter, "expected one of: {:?}", &FIELDS)
5317                    }
5318
5319                    #[allow(unused_variables)]
5320                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5321                    where
5322                        E: serde::de::Error,
5323                    {
5324                        match value {
5325                            "map" => Ok(GeneratedField::Map),
5326                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5327                        }
5328                    }
5329                }
5330                deserializer.deserialize_identifier(GeneratedVisitor)
5331            }
5332        }
5333        struct GeneratedVisitor;
5334        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5335            type Value = FragmentIdToActorIdMap;
5336
5337            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5338                formatter.write_str("struct meta.FragmentIdToActorIdMap")
5339            }
5340
5341            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentIdToActorIdMap, V::Error>
5342                where
5343                    V: serde::de::MapAccess<'de>,
5344            {
5345                let mut map__ = None;
5346                while let Some(k) = map_.next_key()? {
5347                    match k {
5348                        GeneratedField::Map => {
5349                            if map__.is_some() {
5350                                return Err(serde::de::Error::duplicate_field("map"));
5351                            }
5352                            map__ = Some(
5353                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5354                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
5355                            );
5356                        }
5357                    }
5358                }
5359                Ok(FragmentIdToActorIdMap {
5360                    map: map__.unwrap_or_default(),
5361                })
5362            }
5363        }
5364        deserializer.deserialize_struct("meta.FragmentIdToActorIdMap", FIELDS, GeneratedVisitor)
5365    }
5366}
5367impl serde::Serialize for FragmentToRelationMap {
5368    #[allow(deprecated)]
5369    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5370    where
5371        S: serde::Serializer,
5372    {
5373        use serde::ser::SerializeStruct;
5374        let mut len = 0;
5375        if !self.fragment_to_relation_map.is_empty() {
5376            len += 1;
5377        }
5378        let mut struct_ser = serializer.serialize_struct("meta.FragmentToRelationMap", len)?;
5379        if !self.fragment_to_relation_map.is_empty() {
5380            struct_ser.serialize_field("fragmentToRelationMap", &self.fragment_to_relation_map)?;
5381        }
5382        struct_ser.end()
5383    }
5384}
5385impl<'de> serde::Deserialize<'de> for FragmentToRelationMap {
5386    #[allow(deprecated)]
5387    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5388    where
5389        D: serde::Deserializer<'de>,
5390    {
5391        const FIELDS: &[&str] = &[
5392            "fragment_to_relation_map",
5393            "fragmentToRelationMap",
5394        ];
5395
5396        #[allow(clippy::enum_variant_names)]
5397        enum GeneratedField {
5398            FragmentToRelationMap,
5399        }
5400        impl<'de> serde::Deserialize<'de> for GeneratedField {
5401            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5402            where
5403                D: serde::Deserializer<'de>,
5404            {
5405                struct GeneratedVisitor;
5406
5407                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5408                    type Value = GeneratedField;
5409
5410                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5411                        write!(formatter, "expected one of: {:?}", &FIELDS)
5412                    }
5413
5414                    #[allow(unused_variables)]
5415                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5416                    where
5417                        E: serde::de::Error,
5418                    {
5419                        match value {
5420                            "fragmentToRelationMap" | "fragment_to_relation_map" => Ok(GeneratedField::FragmentToRelationMap),
5421                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5422                        }
5423                    }
5424                }
5425                deserializer.deserialize_identifier(GeneratedVisitor)
5426            }
5427        }
5428        struct GeneratedVisitor;
5429        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5430            type Value = FragmentToRelationMap;
5431
5432            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5433                formatter.write_str("struct meta.FragmentToRelationMap")
5434            }
5435
5436            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentToRelationMap, V::Error>
5437                where
5438                    V: serde::de::MapAccess<'de>,
5439            {
5440                let mut fragment_to_relation_map__ = None;
5441                while let Some(k) = map_.next_key()? {
5442                    match k {
5443                        GeneratedField::FragmentToRelationMap => {
5444                            if fragment_to_relation_map__.is_some() {
5445                                return Err(serde::de::Error::duplicate_field("fragmentToRelationMap"));
5446                            }
5447                            fragment_to_relation_map__ = Some(
5448                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
5449                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
5450                            );
5451                        }
5452                    }
5453                }
5454                Ok(FragmentToRelationMap {
5455                    fragment_to_relation_map: fragment_to_relation_map__.unwrap_or_default(),
5456                })
5457            }
5458        }
5459        deserializer.deserialize_struct("meta.FragmentToRelationMap", FIELDS, GeneratedVisitor)
5460    }
5461}
5462impl serde::Serialize for FragmentWorkerSlotMapping {
5463    #[allow(deprecated)]
5464    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5465    where
5466        S: serde::Serializer,
5467    {
5468        use serde::ser::SerializeStruct;
5469        let mut len = 0;
5470        if self.fragment_id != 0 {
5471            len += 1;
5472        }
5473        if self.mapping.is_some() {
5474            len += 1;
5475        }
5476        let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMapping", len)?;
5477        if self.fragment_id != 0 {
5478            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5479        }
5480        if let Some(v) = self.mapping.as_ref() {
5481            struct_ser.serialize_field("mapping", v)?;
5482        }
5483        struct_ser.end()
5484    }
5485}
5486impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMapping {
5487    #[allow(deprecated)]
5488    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5489    where
5490        D: serde::Deserializer<'de>,
5491    {
5492        const FIELDS: &[&str] = &[
5493            "fragment_id",
5494            "fragmentId",
5495            "mapping",
5496        ];
5497
5498        #[allow(clippy::enum_variant_names)]
5499        enum GeneratedField {
5500            FragmentId,
5501            Mapping,
5502        }
5503        impl<'de> serde::Deserialize<'de> for GeneratedField {
5504            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5505            where
5506                D: serde::Deserializer<'de>,
5507            {
5508                struct GeneratedVisitor;
5509
5510                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5511                    type Value = GeneratedField;
5512
5513                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5514                        write!(formatter, "expected one of: {:?}", &FIELDS)
5515                    }
5516
5517                    #[allow(unused_variables)]
5518                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5519                    where
5520                        E: serde::de::Error,
5521                    {
5522                        match value {
5523                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5524                            "mapping" => Ok(GeneratedField::Mapping),
5525                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5526                        }
5527                    }
5528                }
5529                deserializer.deserialize_identifier(GeneratedVisitor)
5530            }
5531        }
5532        struct GeneratedVisitor;
5533        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5534            type Value = FragmentWorkerSlotMapping;
5535
5536            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5537                formatter.write_str("struct meta.FragmentWorkerSlotMapping")
5538            }
5539
5540            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMapping, V::Error>
5541                where
5542                    V: serde::de::MapAccess<'de>,
5543            {
5544                let mut fragment_id__ = None;
5545                let mut mapping__ = None;
5546                while let Some(k) = map_.next_key()? {
5547                    match k {
5548                        GeneratedField::FragmentId => {
5549                            if fragment_id__.is_some() {
5550                                return Err(serde::de::Error::duplicate_field("fragmentId"));
5551                            }
5552                            fragment_id__ = 
5553                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5554                            ;
5555                        }
5556                        GeneratedField::Mapping => {
5557                            if mapping__.is_some() {
5558                                return Err(serde::de::Error::duplicate_field("mapping"));
5559                            }
5560                            mapping__ = map_.next_value()?;
5561                        }
5562                    }
5563                }
5564                Ok(FragmentWorkerSlotMapping {
5565                    fragment_id: fragment_id__.unwrap_or_default(),
5566                    mapping: mapping__,
5567                })
5568            }
5569        }
5570        deserializer.deserialize_struct("meta.FragmentWorkerSlotMapping", FIELDS, GeneratedVisitor)
5571    }
5572}
5573impl serde::Serialize for FragmentWorkerSlotMappings {
5574    #[allow(deprecated)]
5575    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5576    where
5577        S: serde::Serializer,
5578    {
5579        use serde::ser::SerializeStruct;
5580        let mut len = 0;
5581        if !self.mappings.is_empty() {
5582            len += 1;
5583        }
5584        let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMappings", len)?;
5585        if !self.mappings.is_empty() {
5586            struct_ser.serialize_field("mappings", &self.mappings)?;
5587        }
5588        struct_ser.end()
5589    }
5590}
5591impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMappings {
5592    #[allow(deprecated)]
5593    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5594    where
5595        D: serde::Deserializer<'de>,
5596    {
5597        const FIELDS: &[&str] = &[
5598            "mappings",
5599        ];
5600
5601        #[allow(clippy::enum_variant_names)]
5602        enum GeneratedField {
5603            Mappings,
5604        }
5605        impl<'de> serde::Deserialize<'de> for GeneratedField {
5606            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5607            where
5608                D: serde::Deserializer<'de>,
5609            {
5610                struct GeneratedVisitor;
5611
5612                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5613                    type Value = GeneratedField;
5614
5615                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5616                        write!(formatter, "expected one of: {:?}", &FIELDS)
5617                    }
5618
5619                    #[allow(unused_variables)]
5620                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5621                    where
5622                        E: serde::de::Error,
5623                    {
5624                        match value {
5625                            "mappings" => Ok(GeneratedField::Mappings),
5626                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5627                        }
5628                    }
5629                }
5630                deserializer.deserialize_identifier(GeneratedVisitor)
5631            }
5632        }
5633        struct GeneratedVisitor;
5634        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5635            type Value = FragmentWorkerSlotMappings;
5636
5637            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5638                formatter.write_str("struct meta.FragmentWorkerSlotMappings")
5639            }
5640
5641            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMappings, V::Error>
5642                where
5643                    V: serde::de::MapAccess<'de>,
5644            {
5645                let mut mappings__ = None;
5646                while let Some(k) = map_.next_key()? {
5647                    match k {
5648                        GeneratedField::Mappings => {
5649                            if mappings__.is_some() {
5650                                return Err(serde::de::Error::duplicate_field("mappings"));
5651                            }
5652                            mappings__ = Some(map_.next_value()?);
5653                        }
5654                    }
5655                }
5656                Ok(FragmentWorkerSlotMappings {
5657                    mappings: mappings__.unwrap_or_default(),
5658                })
5659            }
5660        }
5661        deserializer.deserialize_struct("meta.FragmentWorkerSlotMappings", FIELDS, GeneratedVisitor)
5662    }
5663}
5664impl serde::Serialize for GetClusterInfoRequest {
5665    #[allow(deprecated)]
5666    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5667    where
5668        S: serde::Serializer,
5669    {
5670        use serde::ser::SerializeStruct;
5671        let len = 0;
5672        let struct_ser = serializer.serialize_struct("meta.GetClusterInfoRequest", len)?;
5673        struct_ser.end()
5674    }
5675}
5676impl<'de> serde::Deserialize<'de> for GetClusterInfoRequest {
5677    #[allow(deprecated)]
5678    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5679    where
5680        D: serde::Deserializer<'de>,
5681    {
5682        const FIELDS: &[&str] = &[
5683        ];
5684
5685        #[allow(clippy::enum_variant_names)]
5686        enum GeneratedField {
5687        }
5688        impl<'de> serde::Deserialize<'de> for GeneratedField {
5689            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5690            where
5691                D: serde::Deserializer<'de>,
5692            {
5693                struct GeneratedVisitor;
5694
5695                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5696                    type Value = GeneratedField;
5697
5698                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5699                        write!(formatter, "expected one of: {:?}", &FIELDS)
5700                    }
5701
5702                    #[allow(unused_variables)]
5703                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5704                    where
5705                        E: serde::de::Error,
5706                    {
5707                            Err(serde::de::Error::unknown_field(value, FIELDS))
5708                    }
5709                }
5710                deserializer.deserialize_identifier(GeneratedVisitor)
5711            }
5712        }
5713        struct GeneratedVisitor;
5714        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5715            type Value = GetClusterInfoRequest;
5716
5717            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5718                formatter.write_str("struct meta.GetClusterInfoRequest")
5719            }
5720
5721            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoRequest, V::Error>
5722                where
5723                    V: serde::de::MapAccess<'de>,
5724            {
5725                while map_.next_key::<GeneratedField>()?.is_some() {
5726                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5727                }
5728                Ok(GetClusterInfoRequest {
5729                })
5730            }
5731        }
5732        deserializer.deserialize_struct("meta.GetClusterInfoRequest", FIELDS, GeneratedVisitor)
5733    }
5734}
5735impl serde::Serialize for GetClusterInfoResponse {
5736    #[allow(deprecated)]
5737    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5738    where
5739        S: serde::Serializer,
5740    {
5741        use serde::ser::SerializeStruct;
5742        let mut len = 0;
5743        if !self.worker_nodes.is_empty() {
5744            len += 1;
5745        }
5746        if !self.table_fragments.is_empty() {
5747            len += 1;
5748        }
5749        if !self.actor_splits.is_empty() {
5750            len += 1;
5751        }
5752        if !self.source_infos.is_empty() {
5753            len += 1;
5754        }
5755        if self.revision != 0 {
5756            len += 1;
5757        }
5758        let mut struct_ser = serializer.serialize_struct("meta.GetClusterInfoResponse", len)?;
5759        if !self.worker_nodes.is_empty() {
5760            struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
5761        }
5762        if !self.table_fragments.is_empty() {
5763            struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
5764        }
5765        if !self.actor_splits.is_empty() {
5766            struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
5767        }
5768        if !self.source_infos.is_empty() {
5769            struct_ser.serialize_field("sourceInfos", &self.source_infos)?;
5770        }
5771        if self.revision != 0 {
5772            #[allow(clippy::needless_borrow)]
5773            #[allow(clippy::needless_borrows_for_generic_args)]
5774            struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
5775        }
5776        struct_ser.end()
5777    }
5778}
5779impl<'de> serde::Deserialize<'de> for GetClusterInfoResponse {
5780    #[allow(deprecated)]
5781    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5782    where
5783        D: serde::Deserializer<'de>,
5784    {
5785        const FIELDS: &[&str] = &[
5786            "worker_nodes",
5787            "workerNodes",
5788            "table_fragments",
5789            "tableFragments",
5790            "actor_splits",
5791            "actorSplits",
5792            "source_infos",
5793            "sourceInfos",
5794            "revision",
5795        ];
5796
5797        #[allow(clippy::enum_variant_names)]
5798        enum GeneratedField {
5799            WorkerNodes,
5800            TableFragments,
5801            ActorSplits,
5802            SourceInfos,
5803            Revision,
5804        }
5805        impl<'de> serde::Deserialize<'de> for GeneratedField {
5806            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5807            where
5808                D: serde::Deserializer<'de>,
5809            {
5810                struct GeneratedVisitor;
5811
5812                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5813                    type Value = GeneratedField;
5814
5815                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5816                        write!(formatter, "expected one of: {:?}", &FIELDS)
5817                    }
5818
5819                    #[allow(unused_variables)]
5820                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5821                    where
5822                        E: serde::de::Error,
5823                    {
5824                        match value {
5825                            "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
5826                            "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
5827                            "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
5828                            "sourceInfos" | "source_infos" => Ok(GeneratedField::SourceInfos),
5829                            "revision" => Ok(GeneratedField::Revision),
5830                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5831                        }
5832                    }
5833                }
5834                deserializer.deserialize_identifier(GeneratedVisitor)
5835            }
5836        }
5837        struct GeneratedVisitor;
5838        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5839            type Value = GetClusterInfoResponse;
5840
5841            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5842                formatter.write_str("struct meta.GetClusterInfoResponse")
5843            }
5844
5845            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoResponse, V::Error>
5846                where
5847                    V: serde::de::MapAccess<'de>,
5848            {
5849                let mut worker_nodes__ = None;
5850                let mut table_fragments__ = None;
5851                let mut actor_splits__ = None;
5852                let mut source_infos__ = None;
5853                let mut revision__ = None;
5854                while let Some(k) = map_.next_key()? {
5855                    match k {
5856                        GeneratedField::WorkerNodes => {
5857                            if worker_nodes__.is_some() {
5858                                return Err(serde::de::Error::duplicate_field("workerNodes"));
5859                            }
5860                            worker_nodes__ = Some(map_.next_value()?);
5861                        }
5862                        GeneratedField::TableFragments => {
5863                            if table_fragments__.is_some() {
5864                                return Err(serde::de::Error::duplicate_field("tableFragments"));
5865                            }
5866                            table_fragments__ = Some(map_.next_value()?);
5867                        }
5868                        GeneratedField::ActorSplits => {
5869                            if actor_splits__.is_some() {
5870                                return Err(serde::de::Error::duplicate_field("actorSplits"));
5871                            }
5872                            actor_splits__ = Some(
5873                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5874                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
5875                            );
5876                        }
5877                        GeneratedField::SourceInfos => {
5878                            if source_infos__.is_some() {
5879                                return Err(serde::de::Error::duplicate_field("sourceInfos"));
5880                            }
5881                            source_infos__ = Some(
5882                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5883                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
5884                            );
5885                        }
5886                        GeneratedField::Revision => {
5887                            if revision__.is_some() {
5888                                return Err(serde::de::Error::duplicate_field("revision"));
5889                            }
5890                            revision__ = 
5891                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5892                            ;
5893                        }
5894                    }
5895                }
5896                Ok(GetClusterInfoResponse {
5897                    worker_nodes: worker_nodes__.unwrap_or_default(),
5898                    table_fragments: table_fragments__.unwrap_or_default(),
5899                    actor_splits: actor_splits__.unwrap_or_default(),
5900                    source_infos: source_infos__.unwrap_or_default(),
5901                    revision: revision__.unwrap_or_default(),
5902                })
5903            }
5904        }
5905        deserializer.deserialize_struct("meta.GetClusterInfoResponse", FIELDS, GeneratedVisitor)
5906    }
5907}
5908impl serde::Serialize for GetClusterLimitsRequest {
5909    #[allow(deprecated)]
5910    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5911    where
5912        S: serde::Serializer,
5913    {
5914        use serde::ser::SerializeStruct;
5915        let len = 0;
5916        let struct_ser = serializer.serialize_struct("meta.GetClusterLimitsRequest", len)?;
5917        struct_ser.end()
5918    }
5919}
5920impl<'de> serde::Deserialize<'de> for GetClusterLimitsRequest {
5921    #[allow(deprecated)]
5922    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5923    where
5924        D: serde::Deserializer<'de>,
5925    {
5926        const FIELDS: &[&str] = &[
5927        ];
5928
5929        #[allow(clippy::enum_variant_names)]
5930        enum GeneratedField {
5931        }
5932        impl<'de> serde::Deserialize<'de> for GeneratedField {
5933            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5934            where
5935                D: serde::Deserializer<'de>,
5936            {
5937                struct GeneratedVisitor;
5938
5939                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5940                    type Value = GeneratedField;
5941
5942                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5943                        write!(formatter, "expected one of: {:?}", &FIELDS)
5944                    }
5945
5946                    #[allow(unused_variables)]
5947                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5948                    where
5949                        E: serde::de::Error,
5950                    {
5951                            Err(serde::de::Error::unknown_field(value, FIELDS))
5952                    }
5953                }
5954                deserializer.deserialize_identifier(GeneratedVisitor)
5955            }
5956        }
5957        struct GeneratedVisitor;
5958        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5959            type Value = GetClusterLimitsRequest;
5960
5961            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5962                formatter.write_str("struct meta.GetClusterLimitsRequest")
5963            }
5964
5965            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsRequest, V::Error>
5966                where
5967                    V: serde::de::MapAccess<'de>,
5968            {
5969                while map_.next_key::<GeneratedField>()?.is_some() {
5970                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5971                }
5972                Ok(GetClusterLimitsRequest {
5973                })
5974            }
5975        }
5976        deserializer.deserialize_struct("meta.GetClusterLimitsRequest", FIELDS, GeneratedVisitor)
5977    }
5978}
5979impl serde::Serialize for GetClusterLimitsResponse {
5980    #[allow(deprecated)]
5981    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5982    where
5983        S: serde::Serializer,
5984    {
5985        use serde::ser::SerializeStruct;
5986        let mut len = 0;
5987        if !self.active_limits.is_empty() {
5988            len += 1;
5989        }
5990        let mut struct_ser = serializer.serialize_struct("meta.GetClusterLimitsResponse", len)?;
5991        if !self.active_limits.is_empty() {
5992            struct_ser.serialize_field("activeLimits", &self.active_limits)?;
5993        }
5994        struct_ser.end()
5995    }
5996}
5997impl<'de> serde::Deserialize<'de> for GetClusterLimitsResponse {
5998    #[allow(deprecated)]
5999    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6000    where
6001        D: serde::Deserializer<'de>,
6002    {
6003        const FIELDS: &[&str] = &[
6004            "active_limits",
6005            "activeLimits",
6006        ];
6007
6008        #[allow(clippy::enum_variant_names)]
6009        enum GeneratedField {
6010            ActiveLimits,
6011        }
6012        impl<'de> serde::Deserialize<'de> for GeneratedField {
6013            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6014            where
6015                D: serde::Deserializer<'de>,
6016            {
6017                struct GeneratedVisitor;
6018
6019                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6020                    type Value = GeneratedField;
6021
6022                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6023                        write!(formatter, "expected one of: {:?}", &FIELDS)
6024                    }
6025
6026                    #[allow(unused_variables)]
6027                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6028                    where
6029                        E: serde::de::Error,
6030                    {
6031                        match value {
6032                            "activeLimits" | "active_limits" => Ok(GeneratedField::ActiveLimits),
6033                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6034                        }
6035                    }
6036                }
6037                deserializer.deserialize_identifier(GeneratedVisitor)
6038            }
6039        }
6040        struct GeneratedVisitor;
6041        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6042            type Value = GetClusterLimitsResponse;
6043
6044            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6045                formatter.write_str("struct meta.GetClusterLimitsResponse")
6046            }
6047
6048            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsResponse, V::Error>
6049                where
6050                    V: serde::de::MapAccess<'de>,
6051            {
6052                let mut active_limits__ = None;
6053                while let Some(k) = map_.next_key()? {
6054                    match k {
6055                        GeneratedField::ActiveLimits => {
6056                            if active_limits__.is_some() {
6057                                return Err(serde::de::Error::duplicate_field("activeLimits"));
6058                            }
6059                            active_limits__ = Some(map_.next_value()?);
6060                        }
6061                    }
6062                }
6063                Ok(GetClusterLimitsResponse {
6064                    active_limits: active_limits__.unwrap_or_default(),
6065                })
6066            }
6067        }
6068        deserializer.deserialize_struct("meta.GetClusterLimitsResponse", FIELDS, GeneratedVisitor)
6069    }
6070}
6071impl serde::Serialize for GetClusterRecoveryStatusRequest {
6072    #[allow(deprecated)]
6073    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6074    where
6075        S: serde::Serializer,
6076    {
6077        use serde::ser::SerializeStruct;
6078        let len = 0;
6079        let struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusRequest", len)?;
6080        struct_ser.end()
6081    }
6082}
6083impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusRequest {
6084    #[allow(deprecated)]
6085    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6086    where
6087        D: serde::Deserializer<'de>,
6088    {
6089        const FIELDS: &[&str] = &[
6090        ];
6091
6092        #[allow(clippy::enum_variant_names)]
6093        enum GeneratedField {
6094        }
6095        impl<'de> serde::Deserialize<'de> for GeneratedField {
6096            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6097            where
6098                D: serde::Deserializer<'de>,
6099            {
6100                struct GeneratedVisitor;
6101
6102                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6103                    type Value = GeneratedField;
6104
6105                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6106                        write!(formatter, "expected one of: {:?}", &FIELDS)
6107                    }
6108
6109                    #[allow(unused_variables)]
6110                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6111                    where
6112                        E: serde::de::Error,
6113                    {
6114                            Err(serde::de::Error::unknown_field(value, FIELDS))
6115                    }
6116                }
6117                deserializer.deserialize_identifier(GeneratedVisitor)
6118            }
6119        }
6120        struct GeneratedVisitor;
6121        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6122            type Value = GetClusterRecoveryStatusRequest;
6123
6124            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6125                formatter.write_str("struct meta.GetClusterRecoveryStatusRequest")
6126            }
6127
6128            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusRequest, V::Error>
6129                where
6130                    V: serde::de::MapAccess<'de>,
6131            {
6132                while map_.next_key::<GeneratedField>()?.is_some() {
6133                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6134                }
6135                Ok(GetClusterRecoveryStatusRequest {
6136                })
6137            }
6138        }
6139        deserializer.deserialize_struct("meta.GetClusterRecoveryStatusRequest", FIELDS, GeneratedVisitor)
6140    }
6141}
6142impl serde::Serialize for GetClusterRecoveryStatusResponse {
6143    #[allow(deprecated)]
6144    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6145    where
6146        S: serde::Serializer,
6147    {
6148        use serde::ser::SerializeStruct;
6149        let mut len = 0;
6150        if self.status != 0 {
6151            len += 1;
6152        }
6153        let mut struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusResponse", len)?;
6154        if self.status != 0 {
6155            let v = RecoveryStatus::try_from(self.status)
6156                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
6157            struct_ser.serialize_field("status", &v)?;
6158        }
6159        struct_ser.end()
6160    }
6161}
6162impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusResponse {
6163    #[allow(deprecated)]
6164    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6165    where
6166        D: serde::Deserializer<'de>,
6167    {
6168        const FIELDS: &[&str] = &[
6169            "status",
6170        ];
6171
6172        #[allow(clippy::enum_variant_names)]
6173        enum GeneratedField {
6174            Status,
6175        }
6176        impl<'de> serde::Deserialize<'de> for GeneratedField {
6177            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6178            where
6179                D: serde::Deserializer<'de>,
6180            {
6181                struct GeneratedVisitor;
6182
6183                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6184                    type Value = GeneratedField;
6185
6186                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6187                        write!(formatter, "expected one of: {:?}", &FIELDS)
6188                    }
6189
6190                    #[allow(unused_variables)]
6191                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6192                    where
6193                        E: serde::de::Error,
6194                    {
6195                        match value {
6196                            "status" => Ok(GeneratedField::Status),
6197                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6198                        }
6199                    }
6200                }
6201                deserializer.deserialize_identifier(GeneratedVisitor)
6202            }
6203        }
6204        struct GeneratedVisitor;
6205        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6206            type Value = GetClusterRecoveryStatusResponse;
6207
6208            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6209                formatter.write_str("struct meta.GetClusterRecoveryStatusResponse")
6210            }
6211
6212            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusResponse, V::Error>
6213                where
6214                    V: serde::de::MapAccess<'de>,
6215            {
6216                let mut status__ = None;
6217                while let Some(k) = map_.next_key()? {
6218                    match k {
6219                        GeneratedField::Status => {
6220                            if status__.is_some() {
6221                                return Err(serde::de::Error::duplicate_field("status"));
6222                            }
6223                            status__ = Some(map_.next_value::<RecoveryStatus>()? as i32);
6224                        }
6225                    }
6226                }
6227                Ok(GetClusterRecoveryStatusResponse {
6228                    status: status__.unwrap_or_default(),
6229                })
6230            }
6231        }
6232        deserializer.deserialize_struct("meta.GetClusterRecoveryStatusResponse", FIELDS, GeneratedVisitor)
6233    }
6234}
6235impl serde::Serialize for GetFragmentByIdRequest {
6236    #[allow(deprecated)]
6237    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6238    where
6239        S: serde::Serializer,
6240    {
6241        use serde::ser::SerializeStruct;
6242        let mut len = 0;
6243        if self.fragment_id != 0 {
6244            len += 1;
6245        }
6246        let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdRequest", len)?;
6247        if self.fragment_id != 0 {
6248            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
6249        }
6250        struct_ser.end()
6251    }
6252}
6253impl<'de> serde::Deserialize<'de> for GetFragmentByIdRequest {
6254    #[allow(deprecated)]
6255    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6256    where
6257        D: serde::Deserializer<'de>,
6258    {
6259        const FIELDS: &[&str] = &[
6260            "fragment_id",
6261            "fragmentId",
6262        ];
6263
6264        #[allow(clippy::enum_variant_names)]
6265        enum GeneratedField {
6266            FragmentId,
6267        }
6268        impl<'de> serde::Deserialize<'de> for GeneratedField {
6269            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6270            where
6271                D: serde::Deserializer<'de>,
6272            {
6273                struct GeneratedVisitor;
6274
6275                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6276                    type Value = GeneratedField;
6277
6278                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6279                        write!(formatter, "expected one of: {:?}", &FIELDS)
6280                    }
6281
6282                    #[allow(unused_variables)]
6283                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6284                    where
6285                        E: serde::de::Error,
6286                    {
6287                        match value {
6288                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
6289                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6290                        }
6291                    }
6292                }
6293                deserializer.deserialize_identifier(GeneratedVisitor)
6294            }
6295        }
6296        struct GeneratedVisitor;
6297        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6298            type Value = GetFragmentByIdRequest;
6299
6300            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6301                formatter.write_str("struct meta.GetFragmentByIdRequest")
6302            }
6303
6304            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdRequest, V::Error>
6305                where
6306                    V: serde::de::MapAccess<'de>,
6307            {
6308                let mut fragment_id__ = None;
6309                while let Some(k) = map_.next_key()? {
6310                    match k {
6311                        GeneratedField::FragmentId => {
6312                            if fragment_id__.is_some() {
6313                                return Err(serde::de::Error::duplicate_field("fragmentId"));
6314                            }
6315                            fragment_id__ = 
6316                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6317                            ;
6318                        }
6319                    }
6320                }
6321                Ok(GetFragmentByIdRequest {
6322                    fragment_id: fragment_id__.unwrap_or_default(),
6323                })
6324            }
6325        }
6326        deserializer.deserialize_struct("meta.GetFragmentByIdRequest", FIELDS, GeneratedVisitor)
6327    }
6328}
6329impl serde::Serialize for GetFragmentByIdResponse {
6330    #[allow(deprecated)]
6331    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6332    where
6333        S: serde::Serializer,
6334    {
6335        use serde::ser::SerializeStruct;
6336        let mut len = 0;
6337        if self.distribution.is_some() {
6338            len += 1;
6339        }
6340        let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdResponse", len)?;
6341        if let Some(v) = self.distribution.as_ref() {
6342            struct_ser.serialize_field("distribution", v)?;
6343        }
6344        struct_ser.end()
6345    }
6346}
6347impl<'de> serde::Deserialize<'de> for GetFragmentByIdResponse {
6348    #[allow(deprecated)]
6349    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6350    where
6351        D: serde::Deserializer<'de>,
6352    {
6353        const FIELDS: &[&str] = &[
6354            "distribution",
6355        ];
6356
6357        #[allow(clippy::enum_variant_names)]
6358        enum GeneratedField {
6359            Distribution,
6360        }
6361        impl<'de> serde::Deserialize<'de> for GeneratedField {
6362            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6363            where
6364                D: serde::Deserializer<'de>,
6365            {
6366                struct GeneratedVisitor;
6367
6368                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6369                    type Value = GeneratedField;
6370
6371                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6372                        write!(formatter, "expected one of: {:?}", &FIELDS)
6373                    }
6374
6375                    #[allow(unused_variables)]
6376                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6377                    where
6378                        E: serde::de::Error,
6379                    {
6380                        match value {
6381                            "distribution" => Ok(GeneratedField::Distribution),
6382                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6383                        }
6384                    }
6385                }
6386                deserializer.deserialize_identifier(GeneratedVisitor)
6387            }
6388        }
6389        struct GeneratedVisitor;
6390        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6391            type Value = GetFragmentByIdResponse;
6392
6393            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6394                formatter.write_str("struct meta.GetFragmentByIdResponse")
6395            }
6396
6397            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdResponse, V::Error>
6398                where
6399                    V: serde::de::MapAccess<'de>,
6400            {
6401                let mut distribution__ = None;
6402                while let Some(k) = map_.next_key()? {
6403                    match k {
6404                        GeneratedField::Distribution => {
6405                            if distribution__.is_some() {
6406                                return Err(serde::de::Error::duplicate_field("distribution"));
6407                            }
6408                            distribution__ = map_.next_value()?;
6409                        }
6410                    }
6411                }
6412                Ok(GetFragmentByIdResponse {
6413                    distribution: distribution__,
6414                })
6415            }
6416        }
6417        deserializer.deserialize_struct("meta.GetFragmentByIdResponse", FIELDS, GeneratedVisitor)
6418    }
6419}
6420impl serde::Serialize for GetMetaStoreInfoRequest {
6421    #[allow(deprecated)]
6422    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6423    where
6424        S: serde::Serializer,
6425    {
6426        use serde::ser::SerializeStruct;
6427        let len = 0;
6428        let struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoRequest", len)?;
6429        struct_ser.end()
6430    }
6431}
6432impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoRequest {
6433    #[allow(deprecated)]
6434    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6435    where
6436        D: serde::Deserializer<'de>,
6437    {
6438        const FIELDS: &[&str] = &[
6439        ];
6440
6441        #[allow(clippy::enum_variant_names)]
6442        enum GeneratedField {
6443        }
6444        impl<'de> serde::Deserialize<'de> for GeneratedField {
6445            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6446            where
6447                D: serde::Deserializer<'de>,
6448            {
6449                struct GeneratedVisitor;
6450
6451                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6452                    type Value = GeneratedField;
6453
6454                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6455                        write!(formatter, "expected one of: {:?}", &FIELDS)
6456                    }
6457
6458                    #[allow(unused_variables)]
6459                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6460                    where
6461                        E: serde::de::Error,
6462                    {
6463                            Err(serde::de::Error::unknown_field(value, FIELDS))
6464                    }
6465                }
6466                deserializer.deserialize_identifier(GeneratedVisitor)
6467            }
6468        }
6469        struct GeneratedVisitor;
6470        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6471            type Value = GetMetaStoreInfoRequest;
6472
6473            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6474                formatter.write_str("struct meta.GetMetaStoreInfoRequest")
6475            }
6476
6477            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoRequest, V::Error>
6478                where
6479                    V: serde::de::MapAccess<'de>,
6480            {
6481                while map_.next_key::<GeneratedField>()?.is_some() {
6482                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6483                }
6484                Ok(GetMetaStoreInfoRequest {
6485                })
6486            }
6487        }
6488        deserializer.deserialize_struct("meta.GetMetaStoreInfoRequest", FIELDS, GeneratedVisitor)
6489    }
6490}
6491impl serde::Serialize for GetMetaStoreInfoResponse {
6492    #[allow(deprecated)]
6493    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6494    where
6495        S: serde::Serializer,
6496    {
6497        use serde::ser::SerializeStruct;
6498        let mut len = 0;
6499        if !self.meta_store_endpoint.is_empty() {
6500            len += 1;
6501        }
6502        let mut struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoResponse", len)?;
6503        if !self.meta_store_endpoint.is_empty() {
6504            struct_ser.serialize_field("metaStoreEndpoint", &self.meta_store_endpoint)?;
6505        }
6506        struct_ser.end()
6507    }
6508}
6509impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoResponse {
6510    #[allow(deprecated)]
6511    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6512    where
6513        D: serde::Deserializer<'de>,
6514    {
6515        const FIELDS: &[&str] = &[
6516            "meta_store_endpoint",
6517            "metaStoreEndpoint",
6518        ];
6519
6520        #[allow(clippy::enum_variant_names)]
6521        enum GeneratedField {
6522            MetaStoreEndpoint,
6523        }
6524        impl<'de> serde::Deserialize<'de> for GeneratedField {
6525            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6526            where
6527                D: serde::Deserializer<'de>,
6528            {
6529                struct GeneratedVisitor;
6530
6531                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6532                    type Value = GeneratedField;
6533
6534                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6535                        write!(formatter, "expected one of: {:?}", &FIELDS)
6536                    }
6537
6538                    #[allow(unused_variables)]
6539                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6540                    where
6541                        E: serde::de::Error,
6542                    {
6543                        match value {
6544                            "metaStoreEndpoint" | "meta_store_endpoint" => Ok(GeneratedField::MetaStoreEndpoint),
6545                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6546                        }
6547                    }
6548                }
6549                deserializer.deserialize_identifier(GeneratedVisitor)
6550            }
6551        }
6552        struct GeneratedVisitor;
6553        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6554            type Value = GetMetaStoreInfoResponse;
6555
6556            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6557                formatter.write_str("struct meta.GetMetaStoreInfoResponse")
6558            }
6559
6560            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoResponse, V::Error>
6561                where
6562                    V: serde::de::MapAccess<'de>,
6563            {
6564                let mut meta_store_endpoint__ = None;
6565                while let Some(k) = map_.next_key()? {
6566                    match k {
6567                        GeneratedField::MetaStoreEndpoint => {
6568                            if meta_store_endpoint__.is_some() {
6569                                return Err(serde::de::Error::duplicate_field("metaStoreEndpoint"));
6570                            }
6571                            meta_store_endpoint__ = Some(map_.next_value()?);
6572                        }
6573                    }
6574                }
6575                Ok(GetMetaStoreInfoResponse {
6576                    meta_store_endpoint: meta_store_endpoint__.unwrap_or_default(),
6577                })
6578            }
6579        }
6580        deserializer.deserialize_struct("meta.GetMetaStoreInfoResponse", FIELDS, GeneratedVisitor)
6581    }
6582}
6583impl serde::Serialize for GetServerlessStreamingJobsStatusRequest {
6584    #[allow(deprecated)]
6585    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6586    where
6587        S: serde::Serializer,
6588    {
6589        use serde::ser::SerializeStruct;
6590        let len = 0;
6591        let struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusRequest", len)?;
6592        struct_ser.end()
6593    }
6594}
6595impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusRequest {
6596    #[allow(deprecated)]
6597    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6598    where
6599        D: serde::Deserializer<'de>,
6600    {
6601        const FIELDS: &[&str] = &[
6602        ];
6603
6604        #[allow(clippy::enum_variant_names)]
6605        enum GeneratedField {
6606        }
6607        impl<'de> serde::Deserialize<'de> for GeneratedField {
6608            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6609            where
6610                D: serde::Deserializer<'de>,
6611            {
6612                struct GeneratedVisitor;
6613
6614                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6615                    type Value = GeneratedField;
6616
6617                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6618                        write!(formatter, "expected one of: {:?}", &FIELDS)
6619                    }
6620
6621                    #[allow(unused_variables)]
6622                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6623                    where
6624                        E: serde::de::Error,
6625                    {
6626                            Err(serde::de::Error::unknown_field(value, FIELDS))
6627                    }
6628                }
6629                deserializer.deserialize_identifier(GeneratedVisitor)
6630            }
6631        }
6632        struct GeneratedVisitor;
6633        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6634            type Value = GetServerlessStreamingJobsStatusRequest;
6635
6636            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6637                formatter.write_str("struct meta.GetServerlessStreamingJobsStatusRequest")
6638            }
6639
6640            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusRequest, V::Error>
6641                where
6642                    V: serde::de::MapAccess<'de>,
6643            {
6644                while map_.next_key::<GeneratedField>()?.is_some() {
6645                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6646                }
6647                Ok(GetServerlessStreamingJobsStatusRequest {
6648                })
6649            }
6650        }
6651        deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusRequest", FIELDS, GeneratedVisitor)
6652    }
6653}
6654impl serde::Serialize for GetServerlessStreamingJobsStatusResponse {
6655    #[allow(deprecated)]
6656    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6657    where
6658        S: serde::Serializer,
6659    {
6660        use serde::ser::SerializeStruct;
6661        let mut len = 0;
6662        if !self.streaming_job_statuses.is_empty() {
6663            len += 1;
6664        }
6665        let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse", len)?;
6666        if !self.streaming_job_statuses.is_empty() {
6667            struct_ser.serialize_field("streamingJobStatuses", &self.streaming_job_statuses)?;
6668        }
6669        struct_ser.end()
6670    }
6671}
6672impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusResponse {
6673    #[allow(deprecated)]
6674    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6675    where
6676        D: serde::Deserializer<'de>,
6677    {
6678        const FIELDS: &[&str] = &[
6679            "streaming_job_statuses",
6680            "streamingJobStatuses",
6681        ];
6682
6683        #[allow(clippy::enum_variant_names)]
6684        enum GeneratedField {
6685            StreamingJobStatuses,
6686        }
6687        impl<'de> serde::Deserialize<'de> for GeneratedField {
6688            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6689            where
6690                D: serde::Deserializer<'de>,
6691            {
6692                struct GeneratedVisitor;
6693
6694                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6695                    type Value = GeneratedField;
6696
6697                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6698                        write!(formatter, "expected one of: {:?}", &FIELDS)
6699                    }
6700
6701                    #[allow(unused_variables)]
6702                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6703                    where
6704                        E: serde::de::Error,
6705                    {
6706                        match value {
6707                            "streamingJobStatuses" | "streaming_job_statuses" => Ok(GeneratedField::StreamingJobStatuses),
6708                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6709                        }
6710                    }
6711                }
6712                deserializer.deserialize_identifier(GeneratedVisitor)
6713            }
6714        }
6715        struct GeneratedVisitor;
6716        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6717            type Value = GetServerlessStreamingJobsStatusResponse;
6718
6719            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6720                formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse")
6721            }
6722
6723            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusResponse, V::Error>
6724                where
6725                    V: serde::de::MapAccess<'de>,
6726            {
6727                let mut streaming_job_statuses__ = None;
6728                while let Some(k) = map_.next_key()? {
6729                    match k {
6730                        GeneratedField::StreamingJobStatuses => {
6731                            if streaming_job_statuses__.is_some() {
6732                                return Err(serde::de::Error::duplicate_field("streamingJobStatuses"));
6733                            }
6734                            streaming_job_statuses__ = Some(map_.next_value()?);
6735                        }
6736                    }
6737                }
6738                Ok(GetServerlessStreamingJobsStatusResponse {
6739                    streaming_job_statuses: streaming_job_statuses__.unwrap_or_default(),
6740                })
6741            }
6742        }
6743        deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse", FIELDS, GeneratedVisitor)
6744    }
6745}
6746impl serde::Serialize for get_serverless_streaming_jobs_status_response::Status {
6747    #[allow(deprecated)]
6748    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6749    where
6750        S: serde::Serializer,
6751    {
6752        use serde::ser::SerializeStruct;
6753        let mut len = 0;
6754        if self.table_id != 0 {
6755            len += 1;
6756        }
6757        if !self.node_label.is_empty() {
6758            len += 1;
6759        }
6760        if self.backfill_done {
6761            len += 1;
6762        }
6763        let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", len)?;
6764        if self.table_id != 0 {
6765            struct_ser.serialize_field("tableId", &self.table_id)?;
6766        }
6767        if !self.node_label.is_empty() {
6768            struct_ser.serialize_field("nodeLabel", &self.node_label)?;
6769        }
6770        if self.backfill_done {
6771            struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
6772        }
6773        struct_ser.end()
6774    }
6775}
6776impl<'de> serde::Deserialize<'de> for get_serverless_streaming_jobs_status_response::Status {
6777    #[allow(deprecated)]
6778    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6779    where
6780        D: serde::Deserializer<'de>,
6781    {
6782        const FIELDS: &[&str] = &[
6783            "table_id",
6784            "tableId",
6785            "node_label",
6786            "nodeLabel",
6787            "backfill_done",
6788            "backfillDone",
6789        ];
6790
6791        #[allow(clippy::enum_variant_names)]
6792        enum GeneratedField {
6793            TableId,
6794            NodeLabel,
6795            BackfillDone,
6796        }
6797        impl<'de> serde::Deserialize<'de> for GeneratedField {
6798            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6799            where
6800                D: serde::Deserializer<'de>,
6801            {
6802                struct GeneratedVisitor;
6803
6804                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6805                    type Value = GeneratedField;
6806
6807                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6808                        write!(formatter, "expected one of: {:?}", &FIELDS)
6809                    }
6810
6811                    #[allow(unused_variables)]
6812                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6813                    where
6814                        E: serde::de::Error,
6815                    {
6816                        match value {
6817                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
6818                            "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
6819                            "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
6820                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6821                        }
6822                    }
6823                }
6824                deserializer.deserialize_identifier(GeneratedVisitor)
6825            }
6826        }
6827        struct GeneratedVisitor;
6828        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6829            type Value = get_serverless_streaming_jobs_status_response::Status;
6830
6831            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6832                formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse.Status")
6833            }
6834
6835            fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_serverless_streaming_jobs_status_response::Status, V::Error>
6836                where
6837                    V: serde::de::MapAccess<'de>,
6838            {
6839                let mut table_id__ = None;
6840                let mut node_label__ = None;
6841                let mut backfill_done__ = None;
6842                while let Some(k) = map_.next_key()? {
6843                    match k {
6844                        GeneratedField::TableId => {
6845                            if table_id__.is_some() {
6846                                return Err(serde::de::Error::duplicate_field("tableId"));
6847                            }
6848                            table_id__ = 
6849                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6850                            ;
6851                        }
6852                        GeneratedField::NodeLabel => {
6853                            if node_label__.is_some() {
6854                                return Err(serde::de::Error::duplicate_field("nodeLabel"));
6855                            }
6856                            node_label__ = Some(map_.next_value()?);
6857                        }
6858                        GeneratedField::BackfillDone => {
6859                            if backfill_done__.is_some() {
6860                                return Err(serde::de::Error::duplicate_field("backfillDone"));
6861                            }
6862                            backfill_done__ = Some(map_.next_value()?);
6863                        }
6864                    }
6865                }
6866                Ok(get_serverless_streaming_jobs_status_response::Status {
6867                    table_id: table_id__.unwrap_or_default(),
6868                    node_label: node_label__.unwrap_or_default(),
6869                    backfill_done: backfill_done__.unwrap_or_default(),
6870                })
6871            }
6872        }
6873        deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", FIELDS, GeneratedVisitor)
6874    }
6875}
6876impl serde::Serialize for GetServingVnodeMappingsRequest {
6877    #[allow(deprecated)]
6878    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6879    where
6880        S: serde::Serializer,
6881    {
6882        use serde::ser::SerializeStruct;
6883        let len = 0;
6884        let struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsRequest", len)?;
6885        struct_ser.end()
6886    }
6887}
6888impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsRequest {
6889    #[allow(deprecated)]
6890    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6891    where
6892        D: serde::Deserializer<'de>,
6893    {
6894        const FIELDS: &[&str] = &[
6895        ];
6896
6897        #[allow(clippy::enum_variant_names)]
6898        enum GeneratedField {
6899        }
6900        impl<'de> serde::Deserialize<'de> for GeneratedField {
6901            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6902            where
6903                D: serde::Deserializer<'de>,
6904            {
6905                struct GeneratedVisitor;
6906
6907                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6908                    type Value = GeneratedField;
6909
6910                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6911                        write!(formatter, "expected one of: {:?}", &FIELDS)
6912                    }
6913
6914                    #[allow(unused_variables)]
6915                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6916                    where
6917                        E: serde::de::Error,
6918                    {
6919                            Err(serde::de::Error::unknown_field(value, FIELDS))
6920                    }
6921                }
6922                deserializer.deserialize_identifier(GeneratedVisitor)
6923            }
6924        }
6925        struct GeneratedVisitor;
6926        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6927            type Value = GetServingVnodeMappingsRequest;
6928
6929            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6930                formatter.write_str("struct meta.GetServingVnodeMappingsRequest")
6931            }
6932
6933            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsRequest, V::Error>
6934                where
6935                    V: serde::de::MapAccess<'de>,
6936            {
6937                while map_.next_key::<GeneratedField>()?.is_some() {
6938                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6939                }
6940                Ok(GetServingVnodeMappingsRequest {
6941                })
6942            }
6943        }
6944        deserializer.deserialize_struct("meta.GetServingVnodeMappingsRequest", FIELDS, GeneratedVisitor)
6945    }
6946}
6947impl serde::Serialize for GetServingVnodeMappingsResponse {
6948    #[allow(deprecated)]
6949    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6950    where
6951        S: serde::Serializer,
6952    {
6953        use serde::ser::SerializeStruct;
6954        let mut len = 0;
6955        if !self.fragment_to_table.is_empty() {
6956            len += 1;
6957        }
6958        if !self.worker_slot_mappings.is_empty() {
6959            len += 1;
6960        }
6961        let mut struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsResponse", len)?;
6962        if !self.fragment_to_table.is_empty() {
6963            struct_ser.serialize_field("fragmentToTable", &self.fragment_to_table)?;
6964        }
6965        if !self.worker_slot_mappings.is_empty() {
6966            struct_ser.serialize_field("workerSlotMappings", &self.worker_slot_mappings)?;
6967        }
6968        struct_ser.end()
6969    }
6970}
6971impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsResponse {
6972    #[allow(deprecated)]
6973    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6974    where
6975        D: serde::Deserializer<'de>,
6976    {
6977        const FIELDS: &[&str] = &[
6978            "fragment_to_table",
6979            "fragmentToTable",
6980            "worker_slot_mappings",
6981            "workerSlotMappings",
6982        ];
6983
6984        #[allow(clippy::enum_variant_names)]
6985        enum GeneratedField {
6986            FragmentToTable,
6987            WorkerSlotMappings,
6988        }
6989        impl<'de> serde::Deserialize<'de> for GeneratedField {
6990            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6991            where
6992                D: serde::Deserializer<'de>,
6993            {
6994                struct GeneratedVisitor;
6995
6996                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6997                    type Value = GeneratedField;
6998
6999                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7000                        write!(formatter, "expected one of: {:?}", &FIELDS)
7001                    }
7002
7003                    #[allow(unused_variables)]
7004                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7005                    where
7006                        E: serde::de::Error,
7007                    {
7008                        match value {
7009                            "fragmentToTable" | "fragment_to_table" => Ok(GeneratedField::FragmentToTable),
7010                            "workerSlotMappings" | "worker_slot_mappings" => Ok(GeneratedField::WorkerSlotMappings),
7011                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7012                        }
7013                    }
7014                }
7015                deserializer.deserialize_identifier(GeneratedVisitor)
7016            }
7017        }
7018        struct GeneratedVisitor;
7019        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7020            type Value = GetServingVnodeMappingsResponse;
7021
7022            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7023                formatter.write_str("struct meta.GetServingVnodeMappingsResponse")
7024            }
7025
7026            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsResponse, V::Error>
7027                where
7028                    V: serde::de::MapAccess<'de>,
7029            {
7030                let mut fragment_to_table__ = None;
7031                let mut worker_slot_mappings__ = None;
7032                while let Some(k) = map_.next_key()? {
7033                    match k {
7034                        GeneratedField::FragmentToTable => {
7035                            if fragment_to_table__.is_some() {
7036                                return Err(serde::de::Error::duplicate_field("fragmentToTable"));
7037                            }
7038                            fragment_to_table__ = Some(
7039                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
7040                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
7041                            );
7042                        }
7043                        GeneratedField::WorkerSlotMappings => {
7044                            if worker_slot_mappings__.is_some() {
7045                                return Err(serde::de::Error::duplicate_field("workerSlotMappings"));
7046                            }
7047                            worker_slot_mappings__ = Some(map_.next_value()?);
7048                        }
7049                    }
7050                }
7051                Ok(GetServingVnodeMappingsResponse {
7052                    fragment_to_table: fragment_to_table__.unwrap_or_default(),
7053                    worker_slot_mappings: worker_slot_mappings__.unwrap_or_default(),
7054                })
7055            }
7056        }
7057        deserializer.deserialize_struct("meta.GetServingVnodeMappingsResponse", FIELDS, GeneratedVisitor)
7058    }
7059}
7060impl serde::Serialize for GetSessionParamsRequest {
7061    #[allow(deprecated)]
7062    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7063    where
7064        S: serde::Serializer,
7065    {
7066        use serde::ser::SerializeStruct;
7067        let len = 0;
7068        let struct_ser = serializer.serialize_struct("meta.GetSessionParamsRequest", len)?;
7069        struct_ser.end()
7070    }
7071}
7072impl<'de> serde::Deserialize<'de> for GetSessionParamsRequest {
7073    #[allow(deprecated)]
7074    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7075    where
7076        D: serde::Deserializer<'de>,
7077    {
7078        const FIELDS: &[&str] = &[
7079        ];
7080
7081        #[allow(clippy::enum_variant_names)]
7082        enum GeneratedField {
7083        }
7084        impl<'de> serde::Deserialize<'de> for GeneratedField {
7085            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7086            where
7087                D: serde::Deserializer<'de>,
7088            {
7089                struct GeneratedVisitor;
7090
7091                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7092                    type Value = GeneratedField;
7093
7094                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7095                        write!(formatter, "expected one of: {:?}", &FIELDS)
7096                    }
7097
7098                    #[allow(unused_variables)]
7099                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7100                    where
7101                        E: serde::de::Error,
7102                    {
7103                            Err(serde::de::Error::unknown_field(value, FIELDS))
7104                    }
7105                }
7106                deserializer.deserialize_identifier(GeneratedVisitor)
7107            }
7108        }
7109        struct GeneratedVisitor;
7110        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7111            type Value = GetSessionParamsRequest;
7112
7113            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7114                formatter.write_str("struct meta.GetSessionParamsRequest")
7115            }
7116
7117            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsRequest, V::Error>
7118                where
7119                    V: serde::de::MapAccess<'de>,
7120            {
7121                while map_.next_key::<GeneratedField>()?.is_some() {
7122                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7123                }
7124                Ok(GetSessionParamsRequest {
7125                })
7126            }
7127        }
7128        deserializer.deserialize_struct("meta.GetSessionParamsRequest", FIELDS, GeneratedVisitor)
7129    }
7130}
7131impl serde::Serialize for GetSessionParamsResponse {
7132    #[allow(deprecated)]
7133    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7134    where
7135        S: serde::Serializer,
7136    {
7137        use serde::ser::SerializeStruct;
7138        let mut len = 0;
7139        if !self.params.is_empty() {
7140            len += 1;
7141        }
7142        let mut struct_ser = serializer.serialize_struct("meta.GetSessionParamsResponse", len)?;
7143        if !self.params.is_empty() {
7144            struct_ser.serialize_field("params", &self.params)?;
7145        }
7146        struct_ser.end()
7147    }
7148}
7149impl<'de> serde::Deserialize<'de> for GetSessionParamsResponse {
7150    #[allow(deprecated)]
7151    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7152    where
7153        D: serde::Deserializer<'de>,
7154    {
7155        const FIELDS: &[&str] = &[
7156            "params",
7157        ];
7158
7159        #[allow(clippy::enum_variant_names)]
7160        enum GeneratedField {
7161            Params,
7162        }
7163        impl<'de> serde::Deserialize<'de> for GeneratedField {
7164            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7165            where
7166                D: serde::Deserializer<'de>,
7167            {
7168                struct GeneratedVisitor;
7169
7170                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7171                    type Value = GeneratedField;
7172
7173                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7174                        write!(formatter, "expected one of: {:?}", &FIELDS)
7175                    }
7176
7177                    #[allow(unused_variables)]
7178                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7179                    where
7180                        E: serde::de::Error,
7181                    {
7182                        match value {
7183                            "params" => Ok(GeneratedField::Params),
7184                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7185                        }
7186                    }
7187                }
7188                deserializer.deserialize_identifier(GeneratedVisitor)
7189            }
7190        }
7191        struct GeneratedVisitor;
7192        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7193            type Value = GetSessionParamsResponse;
7194
7195            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7196                formatter.write_str("struct meta.GetSessionParamsResponse")
7197            }
7198
7199            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsResponse, V::Error>
7200                where
7201                    V: serde::de::MapAccess<'de>,
7202            {
7203                let mut params__ = None;
7204                while let Some(k) = map_.next_key()? {
7205                    match k {
7206                        GeneratedField::Params => {
7207                            if params__.is_some() {
7208                                return Err(serde::de::Error::duplicate_field("params"));
7209                            }
7210                            params__ = Some(map_.next_value()?);
7211                        }
7212                    }
7213                }
7214                Ok(GetSessionParamsResponse {
7215                    params: params__.unwrap_or_default(),
7216                })
7217            }
7218        }
7219        deserializer.deserialize_struct("meta.GetSessionParamsResponse", FIELDS, GeneratedVisitor)
7220    }
7221}
7222impl serde::Serialize for GetSystemParamsRequest {
7223    #[allow(deprecated)]
7224    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7225    where
7226        S: serde::Serializer,
7227    {
7228        use serde::ser::SerializeStruct;
7229        let len = 0;
7230        let struct_ser = serializer.serialize_struct("meta.GetSystemParamsRequest", len)?;
7231        struct_ser.end()
7232    }
7233}
7234impl<'de> serde::Deserialize<'de> for GetSystemParamsRequest {
7235    #[allow(deprecated)]
7236    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7237    where
7238        D: serde::Deserializer<'de>,
7239    {
7240        const FIELDS: &[&str] = &[
7241        ];
7242
7243        #[allow(clippy::enum_variant_names)]
7244        enum GeneratedField {
7245        }
7246        impl<'de> serde::Deserialize<'de> for GeneratedField {
7247            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7248            where
7249                D: serde::Deserializer<'de>,
7250            {
7251                struct GeneratedVisitor;
7252
7253                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7254                    type Value = GeneratedField;
7255
7256                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7257                        write!(formatter, "expected one of: {:?}", &FIELDS)
7258                    }
7259
7260                    #[allow(unused_variables)]
7261                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7262                    where
7263                        E: serde::de::Error,
7264                    {
7265                            Err(serde::de::Error::unknown_field(value, FIELDS))
7266                    }
7267                }
7268                deserializer.deserialize_identifier(GeneratedVisitor)
7269            }
7270        }
7271        struct GeneratedVisitor;
7272        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7273            type Value = GetSystemParamsRequest;
7274
7275            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7276                formatter.write_str("struct meta.GetSystemParamsRequest")
7277            }
7278
7279            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsRequest, V::Error>
7280                where
7281                    V: serde::de::MapAccess<'de>,
7282            {
7283                while map_.next_key::<GeneratedField>()?.is_some() {
7284                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7285                }
7286                Ok(GetSystemParamsRequest {
7287                })
7288            }
7289        }
7290        deserializer.deserialize_struct("meta.GetSystemParamsRequest", FIELDS, GeneratedVisitor)
7291    }
7292}
7293impl serde::Serialize for GetSystemParamsResponse {
7294    #[allow(deprecated)]
7295    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7296    where
7297        S: serde::Serializer,
7298    {
7299        use serde::ser::SerializeStruct;
7300        let mut len = 0;
7301        if self.params.is_some() {
7302            len += 1;
7303        }
7304        let mut struct_ser = serializer.serialize_struct("meta.GetSystemParamsResponse", len)?;
7305        if let Some(v) = self.params.as_ref() {
7306            struct_ser.serialize_field("params", v)?;
7307        }
7308        struct_ser.end()
7309    }
7310}
7311impl<'de> serde::Deserialize<'de> for GetSystemParamsResponse {
7312    #[allow(deprecated)]
7313    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7314    where
7315        D: serde::Deserializer<'de>,
7316    {
7317        const FIELDS: &[&str] = &[
7318            "params",
7319        ];
7320
7321        #[allow(clippy::enum_variant_names)]
7322        enum GeneratedField {
7323            Params,
7324        }
7325        impl<'de> serde::Deserialize<'de> for GeneratedField {
7326            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7327            where
7328                D: serde::Deserializer<'de>,
7329            {
7330                struct GeneratedVisitor;
7331
7332                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7333                    type Value = GeneratedField;
7334
7335                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7336                        write!(formatter, "expected one of: {:?}", &FIELDS)
7337                    }
7338
7339                    #[allow(unused_variables)]
7340                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7341                    where
7342                        E: serde::de::Error,
7343                    {
7344                        match value {
7345                            "params" => Ok(GeneratedField::Params),
7346                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7347                        }
7348                    }
7349                }
7350                deserializer.deserialize_identifier(GeneratedVisitor)
7351            }
7352        }
7353        struct GeneratedVisitor;
7354        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7355            type Value = GetSystemParamsResponse;
7356
7357            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7358                formatter.write_str("struct meta.GetSystemParamsResponse")
7359            }
7360
7361            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsResponse, V::Error>
7362                where
7363                    V: serde::de::MapAccess<'de>,
7364            {
7365                let mut params__ = None;
7366                while let Some(k) = map_.next_key()? {
7367                    match k {
7368                        GeneratedField::Params => {
7369                            if params__.is_some() {
7370                                return Err(serde::de::Error::duplicate_field("params"));
7371                            }
7372                            params__ = map_.next_value()?;
7373                        }
7374                    }
7375                }
7376                Ok(GetSystemParamsResponse {
7377                    params: params__,
7378                })
7379            }
7380        }
7381        deserializer.deserialize_struct("meta.GetSystemParamsResponse", FIELDS, GeneratedVisitor)
7382    }
7383}
7384impl serde::Serialize for GetTelemetryInfoRequest {
7385    #[allow(deprecated)]
7386    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7387    where
7388        S: serde::Serializer,
7389    {
7390        use serde::ser::SerializeStruct;
7391        let len = 0;
7392        let struct_ser = serializer.serialize_struct("meta.GetTelemetryInfoRequest", len)?;
7393        struct_ser.end()
7394    }
7395}
7396impl<'de> serde::Deserialize<'de> for GetTelemetryInfoRequest {
7397    #[allow(deprecated)]
7398    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7399    where
7400        D: serde::Deserializer<'de>,
7401    {
7402        const FIELDS: &[&str] = &[
7403        ];
7404
7405        #[allow(clippy::enum_variant_names)]
7406        enum GeneratedField {
7407        }
7408        impl<'de> serde::Deserialize<'de> for GeneratedField {
7409            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7410            where
7411                D: serde::Deserializer<'de>,
7412            {
7413                struct GeneratedVisitor;
7414
7415                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7416                    type Value = GeneratedField;
7417
7418                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7419                        write!(formatter, "expected one of: {:?}", &FIELDS)
7420                    }
7421
7422                    #[allow(unused_variables)]
7423                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7424                    where
7425                        E: serde::de::Error,
7426                    {
7427                            Err(serde::de::Error::unknown_field(value, FIELDS))
7428                    }
7429                }
7430                deserializer.deserialize_identifier(GeneratedVisitor)
7431            }
7432        }
7433        struct GeneratedVisitor;
7434        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7435            type Value = GetTelemetryInfoRequest;
7436
7437            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7438                formatter.write_str("struct meta.GetTelemetryInfoRequest")
7439            }
7440
7441            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTelemetryInfoRequest, V::Error>
7442                where
7443                    V: serde::de::MapAccess<'de>,
7444            {
7445                while map_.next_key::<GeneratedField>()?.is_some() {
7446                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7447                }
7448                Ok(GetTelemetryInfoRequest {
7449                })
7450            }
7451        }
7452        deserializer.deserialize_struct("meta.GetTelemetryInfoRequest", FIELDS, GeneratedVisitor)
7453    }
7454}
7455impl serde::Serialize for HeartbeatRequest {
7456    #[allow(deprecated)]
7457    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7458    where
7459        S: serde::Serializer,
7460    {
7461        use serde::ser::SerializeStruct;
7462        let mut len = 0;
7463        if self.node_id != 0 {
7464            len += 1;
7465        }
7466        let mut struct_ser = serializer.serialize_struct("meta.HeartbeatRequest", len)?;
7467        if self.node_id != 0 {
7468            struct_ser.serialize_field("nodeId", &self.node_id)?;
7469        }
7470        struct_ser.end()
7471    }
7472}
7473impl<'de> serde::Deserialize<'de> for HeartbeatRequest {
7474    #[allow(deprecated)]
7475    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7476    where
7477        D: serde::Deserializer<'de>,
7478    {
7479        const FIELDS: &[&str] = &[
7480            "node_id",
7481            "nodeId",
7482        ];
7483
7484        #[allow(clippy::enum_variant_names)]
7485        enum GeneratedField {
7486            NodeId,
7487        }
7488        impl<'de> serde::Deserialize<'de> for GeneratedField {
7489            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7490            where
7491                D: serde::Deserializer<'de>,
7492            {
7493                struct GeneratedVisitor;
7494
7495                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7496                    type Value = GeneratedField;
7497
7498                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7499                        write!(formatter, "expected one of: {:?}", &FIELDS)
7500                    }
7501
7502                    #[allow(unused_variables)]
7503                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7504                    where
7505                        E: serde::de::Error,
7506                    {
7507                        match value {
7508                            "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
7509                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7510                        }
7511                    }
7512                }
7513                deserializer.deserialize_identifier(GeneratedVisitor)
7514            }
7515        }
7516        struct GeneratedVisitor;
7517        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7518            type Value = HeartbeatRequest;
7519
7520            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7521                formatter.write_str("struct meta.HeartbeatRequest")
7522            }
7523
7524            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatRequest, V::Error>
7525                where
7526                    V: serde::de::MapAccess<'de>,
7527            {
7528                let mut node_id__ = None;
7529                while let Some(k) = map_.next_key()? {
7530                    match k {
7531                        GeneratedField::NodeId => {
7532                            if node_id__.is_some() {
7533                                return Err(serde::de::Error::duplicate_field("nodeId"));
7534                            }
7535                            node_id__ = 
7536                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7537                            ;
7538                        }
7539                    }
7540                }
7541                Ok(HeartbeatRequest {
7542                    node_id: node_id__.unwrap_or_default(),
7543                })
7544            }
7545        }
7546        deserializer.deserialize_struct("meta.HeartbeatRequest", FIELDS, GeneratedVisitor)
7547    }
7548}
7549impl serde::Serialize for HeartbeatResponse {
7550    #[allow(deprecated)]
7551    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7552    where
7553        S: serde::Serializer,
7554    {
7555        use serde::ser::SerializeStruct;
7556        let mut len = 0;
7557        if self.status.is_some() {
7558            len += 1;
7559        }
7560        let mut struct_ser = serializer.serialize_struct("meta.HeartbeatResponse", len)?;
7561        if let Some(v) = self.status.as_ref() {
7562            struct_ser.serialize_field("status", v)?;
7563        }
7564        struct_ser.end()
7565    }
7566}
7567impl<'de> serde::Deserialize<'de> for HeartbeatResponse {
7568    #[allow(deprecated)]
7569    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7570    where
7571        D: serde::Deserializer<'de>,
7572    {
7573        const FIELDS: &[&str] = &[
7574            "status",
7575        ];
7576
7577        #[allow(clippy::enum_variant_names)]
7578        enum GeneratedField {
7579            Status,
7580        }
7581        impl<'de> serde::Deserialize<'de> for GeneratedField {
7582            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7583            where
7584                D: serde::Deserializer<'de>,
7585            {
7586                struct GeneratedVisitor;
7587
7588                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7589                    type Value = GeneratedField;
7590
7591                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7592                        write!(formatter, "expected one of: {:?}", &FIELDS)
7593                    }
7594
7595                    #[allow(unused_variables)]
7596                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7597                    where
7598                        E: serde::de::Error,
7599                    {
7600                        match value {
7601                            "status" => Ok(GeneratedField::Status),
7602                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7603                        }
7604                    }
7605                }
7606                deserializer.deserialize_identifier(GeneratedVisitor)
7607            }
7608        }
7609        struct GeneratedVisitor;
7610        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7611            type Value = HeartbeatResponse;
7612
7613            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7614                formatter.write_str("struct meta.HeartbeatResponse")
7615            }
7616
7617            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatResponse, V::Error>
7618                where
7619                    V: serde::de::MapAccess<'de>,
7620            {
7621                let mut status__ = None;
7622                while let Some(k) = map_.next_key()? {
7623                    match k {
7624                        GeneratedField::Status => {
7625                            if status__.is_some() {
7626                                return Err(serde::de::Error::duplicate_field("status"));
7627                            }
7628                            status__ = map_.next_value()?;
7629                        }
7630                    }
7631                }
7632                Ok(HeartbeatResponse {
7633                    status: status__,
7634                })
7635            }
7636        }
7637        deserializer.deserialize_struct("meta.HeartbeatResponse", FIELDS, GeneratedVisitor)
7638    }
7639}
7640impl serde::Serialize for ListActorSplitsRequest {
7641    #[allow(deprecated)]
7642    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7643    where
7644        S: serde::Serializer,
7645    {
7646        use serde::ser::SerializeStruct;
7647        let len = 0;
7648        let struct_ser = serializer.serialize_struct("meta.ListActorSplitsRequest", len)?;
7649        struct_ser.end()
7650    }
7651}
7652impl<'de> serde::Deserialize<'de> for ListActorSplitsRequest {
7653    #[allow(deprecated)]
7654    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7655    where
7656        D: serde::Deserializer<'de>,
7657    {
7658        const FIELDS: &[&str] = &[
7659        ];
7660
7661        #[allow(clippy::enum_variant_names)]
7662        enum GeneratedField {
7663        }
7664        impl<'de> serde::Deserialize<'de> for GeneratedField {
7665            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7666            where
7667                D: serde::Deserializer<'de>,
7668            {
7669                struct GeneratedVisitor;
7670
7671                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7672                    type Value = GeneratedField;
7673
7674                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7675                        write!(formatter, "expected one of: {:?}", &FIELDS)
7676                    }
7677
7678                    #[allow(unused_variables)]
7679                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7680                    where
7681                        E: serde::de::Error,
7682                    {
7683                            Err(serde::de::Error::unknown_field(value, FIELDS))
7684                    }
7685                }
7686                deserializer.deserialize_identifier(GeneratedVisitor)
7687            }
7688        }
7689        struct GeneratedVisitor;
7690        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7691            type Value = ListActorSplitsRequest;
7692
7693            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7694                formatter.write_str("struct meta.ListActorSplitsRequest")
7695            }
7696
7697            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsRequest, V::Error>
7698                where
7699                    V: serde::de::MapAccess<'de>,
7700            {
7701                while map_.next_key::<GeneratedField>()?.is_some() {
7702                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7703                }
7704                Ok(ListActorSplitsRequest {
7705                })
7706            }
7707        }
7708        deserializer.deserialize_struct("meta.ListActorSplitsRequest", FIELDS, GeneratedVisitor)
7709    }
7710}
7711impl serde::Serialize for ListActorSplitsResponse {
7712    #[allow(deprecated)]
7713    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7714    where
7715        S: serde::Serializer,
7716    {
7717        use serde::ser::SerializeStruct;
7718        let mut len = 0;
7719        if !self.actor_splits.is_empty() {
7720            len += 1;
7721        }
7722        let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse", len)?;
7723        if !self.actor_splits.is_empty() {
7724            struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
7725        }
7726        struct_ser.end()
7727    }
7728}
7729impl<'de> serde::Deserialize<'de> for ListActorSplitsResponse {
7730    #[allow(deprecated)]
7731    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7732    where
7733        D: serde::Deserializer<'de>,
7734    {
7735        const FIELDS: &[&str] = &[
7736            "actor_splits",
7737            "actorSplits",
7738        ];
7739
7740        #[allow(clippy::enum_variant_names)]
7741        enum GeneratedField {
7742            ActorSplits,
7743        }
7744        impl<'de> serde::Deserialize<'de> for GeneratedField {
7745            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7746            where
7747                D: serde::Deserializer<'de>,
7748            {
7749                struct GeneratedVisitor;
7750
7751                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7752                    type Value = GeneratedField;
7753
7754                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7755                        write!(formatter, "expected one of: {:?}", &FIELDS)
7756                    }
7757
7758                    #[allow(unused_variables)]
7759                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7760                    where
7761                        E: serde::de::Error,
7762                    {
7763                        match value {
7764                            "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
7765                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7766                        }
7767                    }
7768                }
7769                deserializer.deserialize_identifier(GeneratedVisitor)
7770            }
7771        }
7772        struct GeneratedVisitor;
7773        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7774            type Value = ListActorSplitsResponse;
7775
7776            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7777                formatter.write_str("struct meta.ListActorSplitsResponse")
7778            }
7779
7780            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsResponse, V::Error>
7781                where
7782                    V: serde::de::MapAccess<'de>,
7783            {
7784                let mut actor_splits__ = None;
7785                while let Some(k) = map_.next_key()? {
7786                    match k {
7787                        GeneratedField::ActorSplits => {
7788                            if actor_splits__.is_some() {
7789                                return Err(serde::de::Error::duplicate_field("actorSplits"));
7790                            }
7791                            actor_splits__ = Some(map_.next_value()?);
7792                        }
7793                    }
7794                }
7795                Ok(ListActorSplitsResponse {
7796                    actor_splits: actor_splits__.unwrap_or_default(),
7797                })
7798            }
7799        }
7800        deserializer.deserialize_struct("meta.ListActorSplitsResponse", FIELDS, GeneratedVisitor)
7801    }
7802}
7803impl serde::Serialize for list_actor_splits_response::ActorSplit {
7804    #[allow(deprecated)]
7805    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7806    where
7807        S: serde::Serializer,
7808    {
7809        use serde::ser::SerializeStruct;
7810        let mut len = 0;
7811        if self.actor_id != 0 {
7812            len += 1;
7813        }
7814        if self.fragment_id != 0 {
7815            len += 1;
7816        }
7817        if self.source_id != 0 {
7818            len += 1;
7819        }
7820        if !self.split_id.is_empty() {
7821            len += 1;
7822        }
7823        if self.fragment_type != 0 {
7824            len += 1;
7825        }
7826        let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse.ActorSplit", len)?;
7827        if self.actor_id != 0 {
7828            struct_ser.serialize_field("actorId", &self.actor_id)?;
7829        }
7830        if self.fragment_id != 0 {
7831            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
7832        }
7833        if self.source_id != 0 {
7834            struct_ser.serialize_field("sourceId", &self.source_id)?;
7835        }
7836        if !self.split_id.is_empty() {
7837            struct_ser.serialize_field("splitId", &self.split_id)?;
7838        }
7839        if self.fragment_type != 0 {
7840            let v = list_actor_splits_response::FragmentType::try_from(self.fragment_type)
7841                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.fragment_type)))?;
7842            struct_ser.serialize_field("fragmentType", &v)?;
7843        }
7844        struct_ser.end()
7845    }
7846}
7847impl<'de> serde::Deserialize<'de> for list_actor_splits_response::ActorSplit {
7848    #[allow(deprecated)]
7849    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7850    where
7851        D: serde::Deserializer<'de>,
7852    {
7853        const FIELDS: &[&str] = &[
7854            "actor_id",
7855            "actorId",
7856            "fragment_id",
7857            "fragmentId",
7858            "source_id",
7859            "sourceId",
7860            "split_id",
7861            "splitId",
7862            "fragment_type",
7863            "fragmentType",
7864        ];
7865
7866        #[allow(clippy::enum_variant_names)]
7867        enum GeneratedField {
7868            ActorId,
7869            FragmentId,
7870            SourceId,
7871            SplitId,
7872            FragmentType,
7873        }
7874        impl<'de> serde::Deserialize<'de> for GeneratedField {
7875            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7876            where
7877                D: serde::Deserializer<'de>,
7878            {
7879                struct GeneratedVisitor;
7880
7881                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7882                    type Value = GeneratedField;
7883
7884                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7885                        write!(formatter, "expected one of: {:?}", &FIELDS)
7886                    }
7887
7888                    #[allow(unused_variables)]
7889                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7890                    where
7891                        E: serde::de::Error,
7892                    {
7893                        match value {
7894                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
7895                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
7896                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
7897                            "splitId" | "split_id" => Ok(GeneratedField::SplitId),
7898                            "fragmentType" | "fragment_type" => Ok(GeneratedField::FragmentType),
7899                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7900                        }
7901                    }
7902                }
7903                deserializer.deserialize_identifier(GeneratedVisitor)
7904            }
7905        }
7906        struct GeneratedVisitor;
7907        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7908            type Value = list_actor_splits_response::ActorSplit;
7909
7910            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7911                formatter.write_str("struct meta.ListActorSplitsResponse.ActorSplit")
7912            }
7913
7914            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_splits_response::ActorSplit, V::Error>
7915                where
7916                    V: serde::de::MapAccess<'de>,
7917            {
7918                let mut actor_id__ = None;
7919                let mut fragment_id__ = None;
7920                let mut source_id__ = None;
7921                let mut split_id__ = None;
7922                let mut fragment_type__ = None;
7923                while let Some(k) = map_.next_key()? {
7924                    match k {
7925                        GeneratedField::ActorId => {
7926                            if actor_id__.is_some() {
7927                                return Err(serde::de::Error::duplicate_field("actorId"));
7928                            }
7929                            actor_id__ = 
7930                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7931                            ;
7932                        }
7933                        GeneratedField::FragmentId => {
7934                            if fragment_id__.is_some() {
7935                                return Err(serde::de::Error::duplicate_field("fragmentId"));
7936                            }
7937                            fragment_id__ = 
7938                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7939                            ;
7940                        }
7941                        GeneratedField::SourceId => {
7942                            if source_id__.is_some() {
7943                                return Err(serde::de::Error::duplicate_field("sourceId"));
7944                            }
7945                            source_id__ = 
7946                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7947                            ;
7948                        }
7949                        GeneratedField::SplitId => {
7950                            if split_id__.is_some() {
7951                                return Err(serde::de::Error::duplicate_field("splitId"));
7952                            }
7953                            split_id__ = Some(map_.next_value()?);
7954                        }
7955                        GeneratedField::FragmentType => {
7956                            if fragment_type__.is_some() {
7957                                return Err(serde::de::Error::duplicate_field("fragmentType"));
7958                            }
7959                            fragment_type__ = Some(map_.next_value::<list_actor_splits_response::FragmentType>()? as i32);
7960                        }
7961                    }
7962                }
7963                Ok(list_actor_splits_response::ActorSplit {
7964                    actor_id: actor_id__.unwrap_or_default(),
7965                    fragment_id: fragment_id__.unwrap_or_default(),
7966                    source_id: source_id__.unwrap_or_default(),
7967                    split_id: split_id__.unwrap_or_default(),
7968                    fragment_type: fragment_type__.unwrap_or_default(),
7969                })
7970            }
7971        }
7972        deserializer.deserialize_struct("meta.ListActorSplitsResponse.ActorSplit", FIELDS, GeneratedVisitor)
7973    }
7974}
7975impl serde::Serialize for list_actor_splits_response::FragmentType {
7976    #[allow(deprecated)]
7977    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7978    where
7979        S: serde::Serializer,
7980    {
7981        let variant = match self {
7982            Self::Unspecified => "UNSPECIFIED",
7983            Self::NonSharedSource => "NON_SHARED_SOURCE",
7984            Self::SharedSource => "SHARED_SOURCE",
7985            Self::SharedSourceBackfill => "SHARED_SOURCE_BACKFILL",
7986        };
7987        serializer.serialize_str(variant)
7988    }
7989}
7990impl<'de> serde::Deserialize<'de> for list_actor_splits_response::FragmentType {
7991    #[allow(deprecated)]
7992    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7993    where
7994        D: serde::Deserializer<'de>,
7995    {
7996        const FIELDS: &[&str] = &[
7997            "UNSPECIFIED",
7998            "NON_SHARED_SOURCE",
7999            "SHARED_SOURCE",
8000            "SHARED_SOURCE_BACKFILL",
8001        ];
8002
8003        struct GeneratedVisitor;
8004
8005        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8006            type Value = list_actor_splits_response::FragmentType;
8007
8008            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8009                write!(formatter, "expected one of: {:?}", &FIELDS)
8010            }
8011
8012            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8013            where
8014                E: serde::de::Error,
8015            {
8016                i32::try_from(v)
8017                    .ok()
8018                    .and_then(|x| x.try_into().ok())
8019                    .ok_or_else(|| {
8020                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8021                    })
8022            }
8023
8024            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8025            where
8026                E: serde::de::Error,
8027            {
8028                i32::try_from(v)
8029                    .ok()
8030                    .and_then(|x| x.try_into().ok())
8031                    .ok_or_else(|| {
8032                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8033                    })
8034            }
8035
8036            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8037            where
8038                E: serde::de::Error,
8039            {
8040                match value {
8041                    "UNSPECIFIED" => Ok(list_actor_splits_response::FragmentType::Unspecified),
8042                    "NON_SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::NonSharedSource),
8043                    "SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::SharedSource),
8044                    "SHARED_SOURCE_BACKFILL" => Ok(list_actor_splits_response::FragmentType::SharedSourceBackfill),
8045                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8046                }
8047            }
8048        }
8049        deserializer.deserialize_any(GeneratedVisitor)
8050    }
8051}
8052impl serde::Serialize for ListActorStatesRequest {
8053    #[allow(deprecated)]
8054    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8055    where
8056        S: serde::Serializer,
8057    {
8058        use serde::ser::SerializeStruct;
8059        let len = 0;
8060        let struct_ser = serializer.serialize_struct("meta.ListActorStatesRequest", len)?;
8061        struct_ser.end()
8062    }
8063}
8064impl<'de> serde::Deserialize<'de> for ListActorStatesRequest {
8065    #[allow(deprecated)]
8066    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8067    where
8068        D: serde::Deserializer<'de>,
8069    {
8070        const FIELDS: &[&str] = &[
8071        ];
8072
8073        #[allow(clippy::enum_variant_names)]
8074        enum GeneratedField {
8075        }
8076        impl<'de> serde::Deserialize<'de> for GeneratedField {
8077            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8078            where
8079                D: serde::Deserializer<'de>,
8080            {
8081                struct GeneratedVisitor;
8082
8083                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8084                    type Value = GeneratedField;
8085
8086                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8087                        write!(formatter, "expected one of: {:?}", &FIELDS)
8088                    }
8089
8090                    #[allow(unused_variables)]
8091                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8092                    where
8093                        E: serde::de::Error,
8094                    {
8095                            Err(serde::de::Error::unknown_field(value, FIELDS))
8096                    }
8097                }
8098                deserializer.deserialize_identifier(GeneratedVisitor)
8099            }
8100        }
8101        struct GeneratedVisitor;
8102        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8103            type Value = ListActorStatesRequest;
8104
8105            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8106                formatter.write_str("struct meta.ListActorStatesRequest")
8107            }
8108
8109            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesRequest, V::Error>
8110                where
8111                    V: serde::de::MapAccess<'de>,
8112            {
8113                while map_.next_key::<GeneratedField>()?.is_some() {
8114                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8115                }
8116                Ok(ListActorStatesRequest {
8117                })
8118            }
8119        }
8120        deserializer.deserialize_struct("meta.ListActorStatesRequest", FIELDS, GeneratedVisitor)
8121    }
8122}
8123impl serde::Serialize for ListActorStatesResponse {
8124    #[allow(deprecated)]
8125    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8126    where
8127        S: serde::Serializer,
8128    {
8129        use serde::ser::SerializeStruct;
8130        let mut len = 0;
8131        if !self.states.is_empty() {
8132            len += 1;
8133        }
8134        let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse", len)?;
8135        if !self.states.is_empty() {
8136            struct_ser.serialize_field("states", &self.states)?;
8137        }
8138        struct_ser.end()
8139    }
8140}
8141impl<'de> serde::Deserialize<'de> for ListActorStatesResponse {
8142    #[allow(deprecated)]
8143    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8144    where
8145        D: serde::Deserializer<'de>,
8146    {
8147        const FIELDS: &[&str] = &[
8148            "states",
8149        ];
8150
8151        #[allow(clippy::enum_variant_names)]
8152        enum GeneratedField {
8153            States,
8154        }
8155        impl<'de> serde::Deserialize<'de> for GeneratedField {
8156            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8157            where
8158                D: serde::Deserializer<'de>,
8159            {
8160                struct GeneratedVisitor;
8161
8162                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8163                    type Value = GeneratedField;
8164
8165                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8166                        write!(formatter, "expected one of: {:?}", &FIELDS)
8167                    }
8168
8169                    #[allow(unused_variables)]
8170                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8171                    where
8172                        E: serde::de::Error,
8173                    {
8174                        match value {
8175                            "states" => Ok(GeneratedField::States),
8176                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8177                        }
8178                    }
8179                }
8180                deserializer.deserialize_identifier(GeneratedVisitor)
8181            }
8182        }
8183        struct GeneratedVisitor;
8184        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8185            type Value = ListActorStatesResponse;
8186
8187            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8188                formatter.write_str("struct meta.ListActorStatesResponse")
8189            }
8190
8191            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesResponse, V::Error>
8192                where
8193                    V: serde::de::MapAccess<'de>,
8194            {
8195                let mut states__ = None;
8196                while let Some(k) = map_.next_key()? {
8197                    match k {
8198                        GeneratedField::States => {
8199                            if states__.is_some() {
8200                                return Err(serde::de::Error::duplicate_field("states"));
8201                            }
8202                            states__ = Some(map_.next_value()?);
8203                        }
8204                    }
8205                }
8206                Ok(ListActorStatesResponse {
8207                    states: states__.unwrap_or_default(),
8208                })
8209            }
8210        }
8211        deserializer.deserialize_struct("meta.ListActorStatesResponse", FIELDS, GeneratedVisitor)
8212    }
8213}
8214impl serde::Serialize for list_actor_states_response::ActorState {
8215    #[allow(deprecated)]
8216    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8217    where
8218        S: serde::Serializer,
8219    {
8220        use serde::ser::SerializeStruct;
8221        let mut len = 0;
8222        if self.actor_id != 0 {
8223            len += 1;
8224        }
8225        if self.fragment_id != 0 {
8226            len += 1;
8227        }
8228        if self.state != 0 {
8229            len += 1;
8230        }
8231        if self.worker_id != 0 {
8232            len += 1;
8233        }
8234        let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse.ActorState", len)?;
8235        if self.actor_id != 0 {
8236            struct_ser.serialize_field("actorId", &self.actor_id)?;
8237        }
8238        if self.fragment_id != 0 {
8239            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
8240        }
8241        if self.state != 0 {
8242            let v = table_fragments::actor_status::ActorState::try_from(self.state)
8243                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
8244            struct_ser.serialize_field("state", &v)?;
8245        }
8246        if self.worker_id != 0 {
8247            struct_ser.serialize_field("workerId", &self.worker_id)?;
8248        }
8249        struct_ser.end()
8250    }
8251}
8252impl<'de> serde::Deserialize<'de> for list_actor_states_response::ActorState {
8253    #[allow(deprecated)]
8254    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8255    where
8256        D: serde::Deserializer<'de>,
8257    {
8258        const FIELDS: &[&str] = &[
8259            "actor_id",
8260            "actorId",
8261            "fragment_id",
8262            "fragmentId",
8263            "state",
8264            "worker_id",
8265            "workerId",
8266        ];
8267
8268        #[allow(clippy::enum_variant_names)]
8269        enum GeneratedField {
8270            ActorId,
8271            FragmentId,
8272            State,
8273            WorkerId,
8274        }
8275        impl<'de> serde::Deserialize<'de> for GeneratedField {
8276            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8277            where
8278                D: serde::Deserializer<'de>,
8279            {
8280                struct GeneratedVisitor;
8281
8282                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8283                    type Value = GeneratedField;
8284
8285                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8286                        write!(formatter, "expected one of: {:?}", &FIELDS)
8287                    }
8288
8289                    #[allow(unused_variables)]
8290                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8291                    where
8292                        E: serde::de::Error,
8293                    {
8294                        match value {
8295                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
8296                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
8297                            "state" => Ok(GeneratedField::State),
8298                            "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
8299                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8300                        }
8301                    }
8302                }
8303                deserializer.deserialize_identifier(GeneratedVisitor)
8304            }
8305        }
8306        struct GeneratedVisitor;
8307        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8308            type Value = list_actor_states_response::ActorState;
8309
8310            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8311                formatter.write_str("struct meta.ListActorStatesResponse.ActorState")
8312            }
8313
8314            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_states_response::ActorState, V::Error>
8315                where
8316                    V: serde::de::MapAccess<'de>,
8317            {
8318                let mut actor_id__ = None;
8319                let mut fragment_id__ = None;
8320                let mut state__ = None;
8321                let mut worker_id__ = None;
8322                while let Some(k) = map_.next_key()? {
8323                    match k {
8324                        GeneratedField::ActorId => {
8325                            if actor_id__.is_some() {
8326                                return Err(serde::de::Error::duplicate_field("actorId"));
8327                            }
8328                            actor_id__ = 
8329                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8330                            ;
8331                        }
8332                        GeneratedField::FragmentId => {
8333                            if fragment_id__.is_some() {
8334                                return Err(serde::de::Error::duplicate_field("fragmentId"));
8335                            }
8336                            fragment_id__ = 
8337                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8338                            ;
8339                        }
8340                        GeneratedField::State => {
8341                            if state__.is_some() {
8342                                return Err(serde::de::Error::duplicate_field("state"));
8343                            }
8344                            state__ = Some(map_.next_value::<table_fragments::actor_status::ActorState>()? as i32);
8345                        }
8346                        GeneratedField::WorkerId => {
8347                            if worker_id__.is_some() {
8348                                return Err(serde::de::Error::duplicate_field("workerId"));
8349                            }
8350                            worker_id__ = 
8351                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8352                            ;
8353                        }
8354                    }
8355                }
8356                Ok(list_actor_states_response::ActorState {
8357                    actor_id: actor_id__.unwrap_or_default(),
8358                    fragment_id: fragment_id__.unwrap_or_default(),
8359                    state: state__.unwrap_or_default(),
8360                    worker_id: worker_id__.unwrap_or_default(),
8361                })
8362            }
8363        }
8364        deserializer.deserialize_struct("meta.ListActorStatesResponse.ActorState", FIELDS, GeneratedVisitor)
8365    }
8366}
8367impl serde::Serialize for ListAllNodesRequest {
8368    #[allow(deprecated)]
8369    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8370    where
8371        S: serde::Serializer,
8372    {
8373        use serde::ser::SerializeStruct;
8374        let mut len = 0;
8375        if self.worker_type.is_some() {
8376            len += 1;
8377        }
8378        if self.include_starting_nodes {
8379            len += 1;
8380        }
8381        let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesRequest", len)?;
8382        if let Some(v) = self.worker_type.as_ref() {
8383            let v = super::common::WorkerType::try_from(*v)
8384                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
8385            struct_ser.serialize_field("workerType", &v)?;
8386        }
8387        if self.include_starting_nodes {
8388            struct_ser.serialize_field("includeStartingNodes", &self.include_starting_nodes)?;
8389        }
8390        struct_ser.end()
8391    }
8392}
8393impl<'de> serde::Deserialize<'de> for ListAllNodesRequest {
8394    #[allow(deprecated)]
8395    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8396    where
8397        D: serde::Deserializer<'de>,
8398    {
8399        const FIELDS: &[&str] = &[
8400            "worker_type",
8401            "workerType",
8402            "include_starting_nodes",
8403            "includeStartingNodes",
8404        ];
8405
8406        #[allow(clippy::enum_variant_names)]
8407        enum GeneratedField {
8408            WorkerType,
8409            IncludeStartingNodes,
8410        }
8411        impl<'de> serde::Deserialize<'de> for GeneratedField {
8412            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8413            where
8414                D: serde::Deserializer<'de>,
8415            {
8416                struct GeneratedVisitor;
8417
8418                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8419                    type Value = GeneratedField;
8420
8421                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8422                        write!(formatter, "expected one of: {:?}", &FIELDS)
8423                    }
8424
8425                    #[allow(unused_variables)]
8426                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8427                    where
8428                        E: serde::de::Error,
8429                    {
8430                        match value {
8431                            "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
8432                            "includeStartingNodes" | "include_starting_nodes" => Ok(GeneratedField::IncludeStartingNodes),
8433                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8434                        }
8435                    }
8436                }
8437                deserializer.deserialize_identifier(GeneratedVisitor)
8438            }
8439        }
8440        struct GeneratedVisitor;
8441        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8442            type Value = ListAllNodesRequest;
8443
8444            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8445                formatter.write_str("struct meta.ListAllNodesRequest")
8446            }
8447
8448            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesRequest, V::Error>
8449                where
8450                    V: serde::de::MapAccess<'de>,
8451            {
8452                let mut worker_type__ = None;
8453                let mut include_starting_nodes__ = None;
8454                while let Some(k) = map_.next_key()? {
8455                    match k {
8456                        GeneratedField::WorkerType => {
8457                            if worker_type__.is_some() {
8458                                return Err(serde::de::Error::duplicate_field("workerType"));
8459                            }
8460                            worker_type__ = map_.next_value::<::std::option::Option<super::common::WorkerType>>()?.map(|x| x as i32);
8461                        }
8462                        GeneratedField::IncludeStartingNodes => {
8463                            if include_starting_nodes__.is_some() {
8464                                return Err(serde::de::Error::duplicate_field("includeStartingNodes"));
8465                            }
8466                            include_starting_nodes__ = Some(map_.next_value()?);
8467                        }
8468                    }
8469                }
8470                Ok(ListAllNodesRequest {
8471                    worker_type: worker_type__,
8472                    include_starting_nodes: include_starting_nodes__.unwrap_or_default(),
8473                })
8474            }
8475        }
8476        deserializer.deserialize_struct("meta.ListAllNodesRequest", FIELDS, GeneratedVisitor)
8477    }
8478}
8479impl serde::Serialize for ListAllNodesResponse {
8480    #[allow(deprecated)]
8481    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8482    where
8483        S: serde::Serializer,
8484    {
8485        use serde::ser::SerializeStruct;
8486        let mut len = 0;
8487        if self.status.is_some() {
8488            len += 1;
8489        }
8490        if !self.nodes.is_empty() {
8491            len += 1;
8492        }
8493        let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesResponse", len)?;
8494        if let Some(v) = self.status.as_ref() {
8495            struct_ser.serialize_field("status", v)?;
8496        }
8497        if !self.nodes.is_empty() {
8498            struct_ser.serialize_field("nodes", &self.nodes)?;
8499        }
8500        struct_ser.end()
8501    }
8502}
8503impl<'de> serde::Deserialize<'de> for ListAllNodesResponse {
8504    #[allow(deprecated)]
8505    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8506    where
8507        D: serde::Deserializer<'de>,
8508    {
8509        const FIELDS: &[&str] = &[
8510            "status",
8511            "nodes",
8512        ];
8513
8514        #[allow(clippy::enum_variant_names)]
8515        enum GeneratedField {
8516            Status,
8517            Nodes,
8518        }
8519        impl<'de> serde::Deserialize<'de> for GeneratedField {
8520            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8521            where
8522                D: serde::Deserializer<'de>,
8523            {
8524                struct GeneratedVisitor;
8525
8526                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8527                    type Value = GeneratedField;
8528
8529                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8530                        write!(formatter, "expected one of: {:?}", &FIELDS)
8531                    }
8532
8533                    #[allow(unused_variables)]
8534                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8535                    where
8536                        E: serde::de::Error,
8537                    {
8538                        match value {
8539                            "status" => Ok(GeneratedField::Status),
8540                            "nodes" => Ok(GeneratedField::Nodes),
8541                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8542                        }
8543                    }
8544                }
8545                deserializer.deserialize_identifier(GeneratedVisitor)
8546            }
8547        }
8548        struct GeneratedVisitor;
8549        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8550            type Value = ListAllNodesResponse;
8551
8552            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8553                formatter.write_str("struct meta.ListAllNodesResponse")
8554            }
8555
8556            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesResponse, V::Error>
8557                where
8558                    V: serde::de::MapAccess<'de>,
8559            {
8560                let mut status__ = None;
8561                let mut nodes__ = None;
8562                while let Some(k) = map_.next_key()? {
8563                    match k {
8564                        GeneratedField::Status => {
8565                            if status__.is_some() {
8566                                return Err(serde::de::Error::duplicate_field("status"));
8567                            }
8568                            status__ = map_.next_value()?;
8569                        }
8570                        GeneratedField::Nodes => {
8571                            if nodes__.is_some() {
8572                                return Err(serde::de::Error::duplicate_field("nodes"));
8573                            }
8574                            nodes__ = Some(map_.next_value()?);
8575                        }
8576                    }
8577                }
8578                Ok(ListAllNodesResponse {
8579                    status: status__,
8580                    nodes: nodes__.unwrap_or_default(),
8581                })
8582            }
8583        }
8584        deserializer.deserialize_struct("meta.ListAllNodesResponse", FIELDS, GeneratedVisitor)
8585    }
8586}
8587impl serde::Serialize for ListCdcProgressRequest {
8588    #[allow(deprecated)]
8589    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8590    where
8591        S: serde::Serializer,
8592    {
8593        use serde::ser::SerializeStruct;
8594        let len = 0;
8595        let struct_ser = serializer.serialize_struct("meta.ListCdcProgressRequest", len)?;
8596        struct_ser.end()
8597    }
8598}
8599impl<'de> serde::Deserialize<'de> for ListCdcProgressRequest {
8600    #[allow(deprecated)]
8601    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8602    where
8603        D: serde::Deserializer<'de>,
8604    {
8605        const FIELDS: &[&str] = &[
8606        ];
8607
8608        #[allow(clippy::enum_variant_names)]
8609        enum GeneratedField {
8610        }
8611        impl<'de> serde::Deserialize<'de> for GeneratedField {
8612            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8613            where
8614                D: serde::Deserializer<'de>,
8615            {
8616                struct GeneratedVisitor;
8617
8618                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8619                    type Value = GeneratedField;
8620
8621                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8622                        write!(formatter, "expected one of: {:?}", &FIELDS)
8623                    }
8624
8625                    #[allow(unused_variables)]
8626                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8627                    where
8628                        E: serde::de::Error,
8629                    {
8630                            Err(serde::de::Error::unknown_field(value, FIELDS))
8631                    }
8632                }
8633                deserializer.deserialize_identifier(GeneratedVisitor)
8634            }
8635        }
8636        struct GeneratedVisitor;
8637        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8638            type Value = ListCdcProgressRequest;
8639
8640            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8641                formatter.write_str("struct meta.ListCdcProgressRequest")
8642            }
8643
8644            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressRequest, V::Error>
8645                where
8646                    V: serde::de::MapAccess<'de>,
8647            {
8648                while map_.next_key::<GeneratedField>()?.is_some() {
8649                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8650                }
8651                Ok(ListCdcProgressRequest {
8652                })
8653            }
8654        }
8655        deserializer.deserialize_struct("meta.ListCdcProgressRequest", FIELDS, GeneratedVisitor)
8656    }
8657}
8658impl serde::Serialize for ListCdcProgressResponse {
8659    #[allow(deprecated)]
8660    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8661    where
8662        S: serde::Serializer,
8663    {
8664        use serde::ser::SerializeStruct;
8665        let mut len = 0;
8666        if !self.cdc_progress.is_empty() {
8667            len += 1;
8668        }
8669        let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse", len)?;
8670        if !self.cdc_progress.is_empty() {
8671            struct_ser.serialize_field("cdcProgress", &self.cdc_progress)?;
8672        }
8673        struct_ser.end()
8674    }
8675}
8676impl<'de> serde::Deserialize<'de> for ListCdcProgressResponse {
8677    #[allow(deprecated)]
8678    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8679    where
8680        D: serde::Deserializer<'de>,
8681    {
8682        const FIELDS: &[&str] = &[
8683            "cdc_progress",
8684            "cdcProgress",
8685        ];
8686
8687        #[allow(clippy::enum_variant_names)]
8688        enum GeneratedField {
8689            CdcProgress,
8690        }
8691        impl<'de> serde::Deserialize<'de> for GeneratedField {
8692            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8693            where
8694                D: serde::Deserializer<'de>,
8695            {
8696                struct GeneratedVisitor;
8697
8698                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8699                    type Value = GeneratedField;
8700
8701                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8702                        write!(formatter, "expected one of: {:?}", &FIELDS)
8703                    }
8704
8705                    #[allow(unused_variables)]
8706                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8707                    where
8708                        E: serde::de::Error,
8709                    {
8710                        match value {
8711                            "cdcProgress" | "cdc_progress" => Ok(GeneratedField::CdcProgress),
8712                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8713                        }
8714                    }
8715                }
8716                deserializer.deserialize_identifier(GeneratedVisitor)
8717            }
8718        }
8719        struct GeneratedVisitor;
8720        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8721            type Value = ListCdcProgressResponse;
8722
8723            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8724                formatter.write_str("struct meta.ListCdcProgressResponse")
8725            }
8726
8727            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressResponse, V::Error>
8728                where
8729                    V: serde::de::MapAccess<'de>,
8730            {
8731                let mut cdc_progress__ = None;
8732                while let Some(k) = map_.next_key()? {
8733                    match k {
8734                        GeneratedField::CdcProgress => {
8735                            if cdc_progress__.is_some() {
8736                                return Err(serde::de::Error::duplicate_field("cdcProgress"));
8737                            }
8738                            cdc_progress__ = Some(
8739                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8740                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
8741                            );
8742                        }
8743                    }
8744                }
8745                Ok(ListCdcProgressResponse {
8746                    cdc_progress: cdc_progress__.unwrap_or_default(),
8747                })
8748            }
8749        }
8750        deserializer.deserialize_struct("meta.ListCdcProgressResponse", FIELDS, GeneratedVisitor)
8751    }
8752}
8753impl serde::Serialize for list_cdc_progress_response::CdcProgress {
8754    #[allow(deprecated)]
8755    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8756    where
8757        S: serde::Serializer,
8758    {
8759        use serde::ser::SerializeStruct;
8760        let mut len = 0;
8761        if self.split_total_count != 0 {
8762            len += 1;
8763        }
8764        if self.split_backfilled_count != 0 {
8765            len += 1;
8766        }
8767        if self.split_completed_count != 0 {
8768            len += 1;
8769        }
8770        let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse.CdcProgress", len)?;
8771        if self.split_total_count != 0 {
8772            #[allow(clippy::needless_borrow)]
8773            #[allow(clippy::needless_borrows_for_generic_args)]
8774            struct_ser.serialize_field("splitTotalCount", ToString::to_string(&self.split_total_count).as_str())?;
8775        }
8776        if self.split_backfilled_count != 0 {
8777            #[allow(clippy::needless_borrow)]
8778            #[allow(clippy::needless_borrows_for_generic_args)]
8779            struct_ser.serialize_field("splitBackfilledCount", ToString::to_string(&self.split_backfilled_count).as_str())?;
8780        }
8781        if self.split_completed_count != 0 {
8782            #[allow(clippy::needless_borrow)]
8783            #[allow(clippy::needless_borrows_for_generic_args)]
8784            struct_ser.serialize_field("splitCompletedCount", ToString::to_string(&self.split_completed_count).as_str())?;
8785        }
8786        struct_ser.end()
8787    }
8788}
8789impl<'de> serde::Deserialize<'de> for list_cdc_progress_response::CdcProgress {
8790    #[allow(deprecated)]
8791    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8792    where
8793        D: serde::Deserializer<'de>,
8794    {
8795        const FIELDS: &[&str] = &[
8796            "split_total_count",
8797            "splitTotalCount",
8798            "split_backfilled_count",
8799            "splitBackfilledCount",
8800            "split_completed_count",
8801            "splitCompletedCount",
8802        ];
8803
8804        #[allow(clippy::enum_variant_names)]
8805        enum GeneratedField {
8806            SplitTotalCount,
8807            SplitBackfilledCount,
8808            SplitCompletedCount,
8809        }
8810        impl<'de> serde::Deserialize<'de> for GeneratedField {
8811            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8812            where
8813                D: serde::Deserializer<'de>,
8814            {
8815                struct GeneratedVisitor;
8816
8817                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8818                    type Value = GeneratedField;
8819
8820                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8821                        write!(formatter, "expected one of: {:?}", &FIELDS)
8822                    }
8823
8824                    #[allow(unused_variables)]
8825                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8826                    where
8827                        E: serde::de::Error,
8828                    {
8829                        match value {
8830                            "splitTotalCount" | "split_total_count" => Ok(GeneratedField::SplitTotalCount),
8831                            "splitBackfilledCount" | "split_backfilled_count" => Ok(GeneratedField::SplitBackfilledCount),
8832                            "splitCompletedCount" | "split_completed_count" => Ok(GeneratedField::SplitCompletedCount),
8833                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8834                        }
8835                    }
8836                }
8837                deserializer.deserialize_identifier(GeneratedVisitor)
8838            }
8839        }
8840        struct GeneratedVisitor;
8841        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8842            type Value = list_cdc_progress_response::CdcProgress;
8843
8844            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8845                formatter.write_str("struct meta.ListCdcProgressResponse.CdcProgress")
8846            }
8847
8848            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_cdc_progress_response::CdcProgress, V::Error>
8849                where
8850                    V: serde::de::MapAccess<'de>,
8851            {
8852                let mut split_total_count__ = None;
8853                let mut split_backfilled_count__ = None;
8854                let mut split_completed_count__ = None;
8855                while let Some(k) = map_.next_key()? {
8856                    match k {
8857                        GeneratedField::SplitTotalCount => {
8858                            if split_total_count__.is_some() {
8859                                return Err(serde::de::Error::duplicate_field("splitTotalCount"));
8860                            }
8861                            split_total_count__ = 
8862                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8863                            ;
8864                        }
8865                        GeneratedField::SplitBackfilledCount => {
8866                            if split_backfilled_count__.is_some() {
8867                                return Err(serde::de::Error::duplicate_field("splitBackfilledCount"));
8868                            }
8869                            split_backfilled_count__ = 
8870                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8871                            ;
8872                        }
8873                        GeneratedField::SplitCompletedCount => {
8874                            if split_completed_count__.is_some() {
8875                                return Err(serde::de::Error::duplicate_field("splitCompletedCount"));
8876                            }
8877                            split_completed_count__ = 
8878                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8879                            ;
8880                        }
8881                    }
8882                }
8883                Ok(list_cdc_progress_response::CdcProgress {
8884                    split_total_count: split_total_count__.unwrap_or_default(),
8885                    split_backfilled_count: split_backfilled_count__.unwrap_or_default(),
8886                    split_completed_count: split_completed_count__.unwrap_or_default(),
8887                })
8888            }
8889        }
8890        deserializer.deserialize_struct("meta.ListCdcProgressResponse.CdcProgress", FIELDS, GeneratedVisitor)
8891    }
8892}
8893impl serde::Serialize for ListCreatingFragmentDistributionRequest {
8894    #[allow(deprecated)]
8895    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8896    where
8897        S: serde::Serializer,
8898    {
8899        use serde::ser::SerializeStruct;
8900        let len = 0;
8901        let struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionRequest", len)?;
8902        struct_ser.end()
8903    }
8904}
8905impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionRequest {
8906    #[allow(deprecated)]
8907    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8908    where
8909        D: serde::Deserializer<'de>,
8910    {
8911        const FIELDS: &[&str] = &[
8912        ];
8913
8914        #[allow(clippy::enum_variant_names)]
8915        enum GeneratedField {
8916        }
8917        impl<'de> serde::Deserialize<'de> for GeneratedField {
8918            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8919            where
8920                D: serde::Deserializer<'de>,
8921            {
8922                struct GeneratedVisitor;
8923
8924                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8925                    type Value = GeneratedField;
8926
8927                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8928                        write!(formatter, "expected one of: {:?}", &FIELDS)
8929                    }
8930
8931                    #[allow(unused_variables)]
8932                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8933                    where
8934                        E: serde::de::Error,
8935                    {
8936                            Err(serde::de::Error::unknown_field(value, FIELDS))
8937                    }
8938                }
8939                deserializer.deserialize_identifier(GeneratedVisitor)
8940            }
8941        }
8942        struct GeneratedVisitor;
8943        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8944            type Value = ListCreatingFragmentDistributionRequest;
8945
8946            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8947                formatter.write_str("struct meta.ListCreatingFragmentDistributionRequest")
8948            }
8949
8950            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionRequest, V::Error>
8951                where
8952                    V: serde::de::MapAccess<'de>,
8953            {
8954                while map_.next_key::<GeneratedField>()?.is_some() {
8955                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8956                }
8957                Ok(ListCreatingFragmentDistributionRequest {
8958                })
8959            }
8960        }
8961        deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionRequest", FIELDS, GeneratedVisitor)
8962    }
8963}
8964impl serde::Serialize for ListCreatingFragmentDistributionResponse {
8965    #[allow(deprecated)]
8966    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8967    where
8968        S: serde::Serializer,
8969    {
8970        use serde::ser::SerializeStruct;
8971        let mut len = 0;
8972        if !self.distributions.is_empty() {
8973            len += 1;
8974        }
8975        let mut struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionResponse", len)?;
8976        if !self.distributions.is_empty() {
8977            struct_ser.serialize_field("distributions", &self.distributions)?;
8978        }
8979        struct_ser.end()
8980    }
8981}
8982impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionResponse {
8983    #[allow(deprecated)]
8984    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8985    where
8986        D: serde::Deserializer<'de>,
8987    {
8988        const FIELDS: &[&str] = &[
8989            "distributions",
8990        ];
8991
8992        #[allow(clippy::enum_variant_names)]
8993        enum GeneratedField {
8994            Distributions,
8995        }
8996        impl<'de> serde::Deserialize<'de> for GeneratedField {
8997            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8998            where
8999                D: serde::Deserializer<'de>,
9000            {
9001                struct GeneratedVisitor;
9002
9003                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9004                    type Value = GeneratedField;
9005
9006                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9007                        write!(formatter, "expected one of: {:?}", &FIELDS)
9008                    }
9009
9010                    #[allow(unused_variables)]
9011                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9012                    where
9013                        E: serde::de::Error,
9014                    {
9015                        match value {
9016                            "distributions" => Ok(GeneratedField::Distributions),
9017                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9018                        }
9019                    }
9020                }
9021                deserializer.deserialize_identifier(GeneratedVisitor)
9022            }
9023        }
9024        struct GeneratedVisitor;
9025        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9026            type Value = ListCreatingFragmentDistributionResponse;
9027
9028            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9029                formatter.write_str("struct meta.ListCreatingFragmentDistributionResponse")
9030            }
9031
9032            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionResponse, V::Error>
9033                where
9034                    V: serde::de::MapAccess<'de>,
9035            {
9036                let mut distributions__ = None;
9037                while let Some(k) = map_.next_key()? {
9038                    match k {
9039                        GeneratedField::Distributions => {
9040                            if distributions__.is_some() {
9041                                return Err(serde::de::Error::duplicate_field("distributions"));
9042                            }
9043                            distributions__ = Some(map_.next_value()?);
9044                        }
9045                    }
9046                }
9047                Ok(ListCreatingFragmentDistributionResponse {
9048                    distributions: distributions__.unwrap_or_default(),
9049                })
9050            }
9051        }
9052        deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionResponse", FIELDS, GeneratedVisitor)
9053    }
9054}
9055impl serde::Serialize for ListEventLogRequest {
9056    #[allow(deprecated)]
9057    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9058    where
9059        S: serde::Serializer,
9060    {
9061        use serde::ser::SerializeStruct;
9062        let len = 0;
9063        let struct_ser = serializer.serialize_struct("meta.ListEventLogRequest", len)?;
9064        struct_ser.end()
9065    }
9066}
9067impl<'de> serde::Deserialize<'de> for ListEventLogRequest {
9068    #[allow(deprecated)]
9069    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9070    where
9071        D: serde::Deserializer<'de>,
9072    {
9073        const FIELDS: &[&str] = &[
9074        ];
9075
9076        #[allow(clippy::enum_variant_names)]
9077        enum GeneratedField {
9078        }
9079        impl<'de> serde::Deserialize<'de> for GeneratedField {
9080            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9081            where
9082                D: serde::Deserializer<'de>,
9083            {
9084                struct GeneratedVisitor;
9085
9086                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9087                    type Value = GeneratedField;
9088
9089                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9090                        write!(formatter, "expected one of: {:?}", &FIELDS)
9091                    }
9092
9093                    #[allow(unused_variables)]
9094                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9095                    where
9096                        E: serde::de::Error,
9097                    {
9098                            Err(serde::de::Error::unknown_field(value, FIELDS))
9099                    }
9100                }
9101                deserializer.deserialize_identifier(GeneratedVisitor)
9102            }
9103        }
9104        struct GeneratedVisitor;
9105        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9106            type Value = ListEventLogRequest;
9107
9108            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9109                formatter.write_str("struct meta.ListEventLogRequest")
9110            }
9111
9112            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogRequest, V::Error>
9113                where
9114                    V: serde::de::MapAccess<'de>,
9115            {
9116                while map_.next_key::<GeneratedField>()?.is_some() {
9117                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9118                }
9119                Ok(ListEventLogRequest {
9120                })
9121            }
9122        }
9123        deserializer.deserialize_struct("meta.ListEventLogRequest", FIELDS, GeneratedVisitor)
9124    }
9125}
9126impl serde::Serialize for ListEventLogResponse {
9127    #[allow(deprecated)]
9128    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9129    where
9130        S: serde::Serializer,
9131    {
9132        use serde::ser::SerializeStruct;
9133        let mut len = 0;
9134        if !self.event_logs.is_empty() {
9135            len += 1;
9136        }
9137        let mut struct_ser = serializer.serialize_struct("meta.ListEventLogResponse", len)?;
9138        if !self.event_logs.is_empty() {
9139            struct_ser.serialize_field("eventLogs", &self.event_logs)?;
9140        }
9141        struct_ser.end()
9142    }
9143}
9144impl<'de> serde::Deserialize<'de> for ListEventLogResponse {
9145    #[allow(deprecated)]
9146    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9147    where
9148        D: serde::Deserializer<'de>,
9149    {
9150        const FIELDS: &[&str] = &[
9151            "event_logs",
9152            "eventLogs",
9153        ];
9154
9155        #[allow(clippy::enum_variant_names)]
9156        enum GeneratedField {
9157            EventLogs,
9158        }
9159        impl<'de> serde::Deserialize<'de> for GeneratedField {
9160            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9161            where
9162                D: serde::Deserializer<'de>,
9163            {
9164                struct GeneratedVisitor;
9165
9166                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9167                    type Value = GeneratedField;
9168
9169                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9170                        write!(formatter, "expected one of: {:?}", &FIELDS)
9171                    }
9172
9173                    #[allow(unused_variables)]
9174                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9175                    where
9176                        E: serde::de::Error,
9177                    {
9178                        match value {
9179                            "eventLogs" | "event_logs" => Ok(GeneratedField::EventLogs),
9180                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9181                        }
9182                    }
9183                }
9184                deserializer.deserialize_identifier(GeneratedVisitor)
9185            }
9186        }
9187        struct GeneratedVisitor;
9188        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9189            type Value = ListEventLogResponse;
9190
9191            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9192                formatter.write_str("struct meta.ListEventLogResponse")
9193            }
9194
9195            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogResponse, V::Error>
9196                where
9197                    V: serde::de::MapAccess<'de>,
9198            {
9199                let mut event_logs__ = None;
9200                while let Some(k) = map_.next_key()? {
9201                    match k {
9202                        GeneratedField::EventLogs => {
9203                            if event_logs__.is_some() {
9204                                return Err(serde::de::Error::duplicate_field("eventLogs"));
9205                            }
9206                            event_logs__ = Some(map_.next_value()?);
9207                        }
9208                    }
9209                }
9210                Ok(ListEventLogResponse {
9211                    event_logs: event_logs__.unwrap_or_default(),
9212                })
9213            }
9214        }
9215        deserializer.deserialize_struct("meta.ListEventLogResponse", FIELDS, GeneratedVisitor)
9216    }
9217}
9218impl serde::Serialize for ListFragmentDistributionRequest {
9219    #[allow(deprecated)]
9220    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9221    where
9222        S: serde::Serializer,
9223    {
9224        use serde::ser::SerializeStruct;
9225        let len = 0;
9226        let struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionRequest", len)?;
9227        struct_ser.end()
9228    }
9229}
9230impl<'de> serde::Deserialize<'de> for ListFragmentDistributionRequest {
9231    #[allow(deprecated)]
9232    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9233    where
9234        D: serde::Deserializer<'de>,
9235    {
9236        const FIELDS: &[&str] = &[
9237        ];
9238
9239        #[allow(clippy::enum_variant_names)]
9240        enum GeneratedField {
9241        }
9242        impl<'de> serde::Deserialize<'de> for GeneratedField {
9243            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9244            where
9245                D: serde::Deserializer<'de>,
9246            {
9247                struct GeneratedVisitor;
9248
9249                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9250                    type Value = GeneratedField;
9251
9252                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9253                        write!(formatter, "expected one of: {:?}", &FIELDS)
9254                    }
9255
9256                    #[allow(unused_variables)]
9257                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9258                    where
9259                        E: serde::de::Error,
9260                    {
9261                            Err(serde::de::Error::unknown_field(value, FIELDS))
9262                    }
9263                }
9264                deserializer.deserialize_identifier(GeneratedVisitor)
9265            }
9266        }
9267        struct GeneratedVisitor;
9268        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9269            type Value = ListFragmentDistributionRequest;
9270
9271            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9272                formatter.write_str("struct meta.ListFragmentDistributionRequest")
9273            }
9274
9275            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionRequest, V::Error>
9276                where
9277                    V: serde::de::MapAccess<'de>,
9278            {
9279                while map_.next_key::<GeneratedField>()?.is_some() {
9280                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9281                }
9282                Ok(ListFragmentDistributionRequest {
9283                })
9284            }
9285        }
9286        deserializer.deserialize_struct("meta.ListFragmentDistributionRequest", FIELDS, GeneratedVisitor)
9287    }
9288}
9289impl serde::Serialize for ListFragmentDistributionResponse {
9290    #[allow(deprecated)]
9291    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9292    where
9293        S: serde::Serializer,
9294    {
9295        use serde::ser::SerializeStruct;
9296        let mut len = 0;
9297        if !self.distributions.is_empty() {
9298            len += 1;
9299        }
9300        let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionResponse", len)?;
9301        if !self.distributions.is_empty() {
9302            struct_ser.serialize_field("distributions", &self.distributions)?;
9303        }
9304        struct_ser.end()
9305    }
9306}
9307impl<'de> serde::Deserialize<'de> for ListFragmentDistributionResponse {
9308    #[allow(deprecated)]
9309    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9310    where
9311        D: serde::Deserializer<'de>,
9312    {
9313        const FIELDS: &[&str] = &[
9314            "distributions",
9315        ];
9316
9317        #[allow(clippy::enum_variant_names)]
9318        enum GeneratedField {
9319            Distributions,
9320        }
9321        impl<'de> serde::Deserialize<'de> for GeneratedField {
9322            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9323            where
9324                D: serde::Deserializer<'de>,
9325            {
9326                struct GeneratedVisitor;
9327
9328                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9329                    type Value = GeneratedField;
9330
9331                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9332                        write!(formatter, "expected one of: {:?}", &FIELDS)
9333                    }
9334
9335                    #[allow(unused_variables)]
9336                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9337                    where
9338                        E: serde::de::Error,
9339                    {
9340                        match value {
9341                            "distributions" => Ok(GeneratedField::Distributions),
9342                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9343                        }
9344                    }
9345                }
9346                deserializer.deserialize_identifier(GeneratedVisitor)
9347            }
9348        }
9349        struct GeneratedVisitor;
9350        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9351            type Value = ListFragmentDistributionResponse;
9352
9353            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9354                formatter.write_str("struct meta.ListFragmentDistributionResponse")
9355            }
9356
9357            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionResponse, V::Error>
9358                where
9359                    V: serde::de::MapAccess<'de>,
9360            {
9361                let mut distributions__ = None;
9362                while let Some(k) = map_.next_key()? {
9363                    match k {
9364                        GeneratedField::Distributions => {
9365                            if distributions__.is_some() {
9366                                return Err(serde::de::Error::duplicate_field("distributions"));
9367                            }
9368                            distributions__ = Some(map_.next_value()?);
9369                        }
9370                    }
9371                }
9372                Ok(ListFragmentDistributionResponse {
9373                    distributions: distributions__.unwrap_or_default(),
9374                })
9375            }
9376        }
9377        deserializer.deserialize_struct("meta.ListFragmentDistributionResponse", FIELDS, GeneratedVisitor)
9378    }
9379}
9380impl serde::Serialize for ListIcebergTablesRequest {
9381    #[allow(deprecated)]
9382    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9383    where
9384        S: serde::Serializer,
9385    {
9386        use serde::ser::SerializeStruct;
9387        let len = 0;
9388        let struct_ser = serializer.serialize_struct("meta.ListIcebergTablesRequest", len)?;
9389        struct_ser.end()
9390    }
9391}
9392impl<'de> serde::Deserialize<'de> for ListIcebergTablesRequest {
9393    #[allow(deprecated)]
9394    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9395    where
9396        D: serde::Deserializer<'de>,
9397    {
9398        const FIELDS: &[&str] = &[
9399        ];
9400
9401        #[allow(clippy::enum_variant_names)]
9402        enum GeneratedField {
9403        }
9404        impl<'de> serde::Deserialize<'de> for GeneratedField {
9405            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9406            where
9407                D: serde::Deserializer<'de>,
9408            {
9409                struct GeneratedVisitor;
9410
9411                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9412                    type Value = GeneratedField;
9413
9414                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9415                        write!(formatter, "expected one of: {:?}", &FIELDS)
9416                    }
9417
9418                    #[allow(unused_variables)]
9419                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9420                    where
9421                        E: serde::de::Error,
9422                    {
9423                            Err(serde::de::Error::unknown_field(value, FIELDS))
9424                    }
9425                }
9426                deserializer.deserialize_identifier(GeneratedVisitor)
9427            }
9428        }
9429        struct GeneratedVisitor;
9430        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9431            type Value = ListIcebergTablesRequest;
9432
9433            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9434                formatter.write_str("struct meta.ListIcebergTablesRequest")
9435            }
9436
9437            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesRequest, V::Error>
9438                where
9439                    V: serde::de::MapAccess<'de>,
9440            {
9441                while map_.next_key::<GeneratedField>()?.is_some() {
9442                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9443                }
9444                Ok(ListIcebergTablesRequest {
9445                })
9446            }
9447        }
9448        deserializer.deserialize_struct("meta.ListIcebergTablesRequest", FIELDS, GeneratedVisitor)
9449    }
9450}
9451impl serde::Serialize for ListIcebergTablesResponse {
9452    #[allow(deprecated)]
9453    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9454    where
9455        S: serde::Serializer,
9456    {
9457        use serde::ser::SerializeStruct;
9458        let mut len = 0;
9459        if !self.iceberg_tables.is_empty() {
9460            len += 1;
9461        }
9462        let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse", len)?;
9463        if !self.iceberg_tables.is_empty() {
9464            struct_ser.serialize_field("icebergTables", &self.iceberg_tables)?;
9465        }
9466        struct_ser.end()
9467    }
9468}
9469impl<'de> serde::Deserialize<'de> for ListIcebergTablesResponse {
9470    #[allow(deprecated)]
9471    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9472    where
9473        D: serde::Deserializer<'de>,
9474    {
9475        const FIELDS: &[&str] = &[
9476            "iceberg_tables",
9477            "icebergTables",
9478        ];
9479
9480        #[allow(clippy::enum_variant_names)]
9481        enum GeneratedField {
9482            IcebergTables,
9483        }
9484        impl<'de> serde::Deserialize<'de> for GeneratedField {
9485            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9486            where
9487                D: serde::Deserializer<'de>,
9488            {
9489                struct GeneratedVisitor;
9490
9491                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9492                    type Value = GeneratedField;
9493
9494                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9495                        write!(formatter, "expected one of: {:?}", &FIELDS)
9496                    }
9497
9498                    #[allow(unused_variables)]
9499                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9500                    where
9501                        E: serde::de::Error,
9502                    {
9503                        match value {
9504                            "icebergTables" | "iceberg_tables" => Ok(GeneratedField::IcebergTables),
9505                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9506                        }
9507                    }
9508                }
9509                deserializer.deserialize_identifier(GeneratedVisitor)
9510            }
9511        }
9512        struct GeneratedVisitor;
9513        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9514            type Value = ListIcebergTablesResponse;
9515
9516            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9517                formatter.write_str("struct meta.ListIcebergTablesResponse")
9518            }
9519
9520            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesResponse, V::Error>
9521                where
9522                    V: serde::de::MapAccess<'de>,
9523            {
9524                let mut iceberg_tables__ = None;
9525                while let Some(k) = map_.next_key()? {
9526                    match k {
9527                        GeneratedField::IcebergTables => {
9528                            if iceberg_tables__.is_some() {
9529                                return Err(serde::de::Error::duplicate_field("icebergTables"));
9530                            }
9531                            iceberg_tables__ = Some(map_.next_value()?);
9532                        }
9533                    }
9534                }
9535                Ok(ListIcebergTablesResponse {
9536                    iceberg_tables: iceberg_tables__.unwrap_or_default(),
9537                })
9538            }
9539        }
9540        deserializer.deserialize_struct("meta.ListIcebergTablesResponse", FIELDS, GeneratedVisitor)
9541    }
9542}
9543impl serde::Serialize for list_iceberg_tables_response::IcebergTable {
9544    #[allow(deprecated)]
9545    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9546    where
9547        S: serde::Serializer,
9548    {
9549        use serde::ser::SerializeStruct;
9550        let mut len = 0;
9551        if !self.catalog_name.is_empty() {
9552            len += 1;
9553        }
9554        if !self.table_namespace.is_empty() {
9555            len += 1;
9556        }
9557        if !self.table_name.is_empty() {
9558            len += 1;
9559        }
9560        if self.metadata_location.is_some() {
9561            len += 1;
9562        }
9563        if self.previous_metadata_location.is_some() {
9564            len += 1;
9565        }
9566        if self.iceberg_type.is_some() {
9567            len += 1;
9568        }
9569        let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse.IcebergTable", len)?;
9570        if !self.catalog_name.is_empty() {
9571            struct_ser.serialize_field("catalogName", &self.catalog_name)?;
9572        }
9573        if !self.table_namespace.is_empty() {
9574            struct_ser.serialize_field("tableNamespace", &self.table_namespace)?;
9575        }
9576        if !self.table_name.is_empty() {
9577            struct_ser.serialize_field("tableName", &self.table_name)?;
9578        }
9579        if let Some(v) = self.metadata_location.as_ref() {
9580            struct_ser.serialize_field("metadataLocation", v)?;
9581        }
9582        if let Some(v) = self.previous_metadata_location.as_ref() {
9583            struct_ser.serialize_field("previousMetadataLocation", v)?;
9584        }
9585        if let Some(v) = self.iceberg_type.as_ref() {
9586            struct_ser.serialize_field("icebergType", v)?;
9587        }
9588        struct_ser.end()
9589    }
9590}
9591impl<'de> serde::Deserialize<'de> for list_iceberg_tables_response::IcebergTable {
9592    #[allow(deprecated)]
9593    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9594    where
9595        D: serde::Deserializer<'de>,
9596    {
9597        const FIELDS: &[&str] = &[
9598            "catalog_name",
9599            "catalogName",
9600            "table_namespace",
9601            "tableNamespace",
9602            "table_name",
9603            "tableName",
9604            "metadata_location",
9605            "metadataLocation",
9606            "previous_metadata_location",
9607            "previousMetadataLocation",
9608            "iceberg_type",
9609            "icebergType",
9610        ];
9611
9612        #[allow(clippy::enum_variant_names)]
9613        enum GeneratedField {
9614            CatalogName,
9615            TableNamespace,
9616            TableName,
9617            MetadataLocation,
9618            PreviousMetadataLocation,
9619            IcebergType,
9620        }
9621        impl<'de> serde::Deserialize<'de> for GeneratedField {
9622            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9623            where
9624                D: serde::Deserializer<'de>,
9625            {
9626                struct GeneratedVisitor;
9627
9628                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9629                    type Value = GeneratedField;
9630
9631                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9632                        write!(formatter, "expected one of: {:?}", &FIELDS)
9633                    }
9634
9635                    #[allow(unused_variables)]
9636                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9637                    where
9638                        E: serde::de::Error,
9639                    {
9640                        match value {
9641                            "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
9642                            "tableNamespace" | "table_namespace" => Ok(GeneratedField::TableNamespace),
9643                            "tableName" | "table_name" => Ok(GeneratedField::TableName),
9644                            "metadataLocation" | "metadata_location" => Ok(GeneratedField::MetadataLocation),
9645                            "previousMetadataLocation" | "previous_metadata_location" => Ok(GeneratedField::PreviousMetadataLocation),
9646                            "icebergType" | "iceberg_type" => Ok(GeneratedField::IcebergType),
9647                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9648                        }
9649                    }
9650                }
9651                deserializer.deserialize_identifier(GeneratedVisitor)
9652            }
9653        }
9654        struct GeneratedVisitor;
9655        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9656            type Value = list_iceberg_tables_response::IcebergTable;
9657
9658            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9659                formatter.write_str("struct meta.ListIcebergTablesResponse.IcebergTable")
9660            }
9661
9662            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_tables_response::IcebergTable, V::Error>
9663                where
9664                    V: serde::de::MapAccess<'de>,
9665            {
9666                let mut catalog_name__ = None;
9667                let mut table_namespace__ = None;
9668                let mut table_name__ = None;
9669                let mut metadata_location__ = None;
9670                let mut previous_metadata_location__ = None;
9671                let mut iceberg_type__ = None;
9672                while let Some(k) = map_.next_key()? {
9673                    match k {
9674                        GeneratedField::CatalogName => {
9675                            if catalog_name__.is_some() {
9676                                return Err(serde::de::Error::duplicate_field("catalogName"));
9677                            }
9678                            catalog_name__ = Some(map_.next_value()?);
9679                        }
9680                        GeneratedField::TableNamespace => {
9681                            if table_namespace__.is_some() {
9682                                return Err(serde::de::Error::duplicate_field("tableNamespace"));
9683                            }
9684                            table_namespace__ = Some(map_.next_value()?);
9685                        }
9686                        GeneratedField::TableName => {
9687                            if table_name__.is_some() {
9688                                return Err(serde::de::Error::duplicate_field("tableName"));
9689                            }
9690                            table_name__ = Some(map_.next_value()?);
9691                        }
9692                        GeneratedField::MetadataLocation => {
9693                            if metadata_location__.is_some() {
9694                                return Err(serde::de::Error::duplicate_field("metadataLocation"));
9695                            }
9696                            metadata_location__ = map_.next_value()?;
9697                        }
9698                        GeneratedField::PreviousMetadataLocation => {
9699                            if previous_metadata_location__.is_some() {
9700                                return Err(serde::de::Error::duplicate_field("previousMetadataLocation"));
9701                            }
9702                            previous_metadata_location__ = map_.next_value()?;
9703                        }
9704                        GeneratedField::IcebergType => {
9705                            if iceberg_type__.is_some() {
9706                                return Err(serde::de::Error::duplicate_field("icebergType"));
9707                            }
9708                            iceberg_type__ = map_.next_value()?;
9709                        }
9710                    }
9711                }
9712                Ok(list_iceberg_tables_response::IcebergTable {
9713                    catalog_name: catalog_name__.unwrap_or_default(),
9714                    table_namespace: table_namespace__.unwrap_or_default(),
9715                    table_name: table_name__.unwrap_or_default(),
9716                    metadata_location: metadata_location__,
9717                    previous_metadata_location: previous_metadata_location__,
9718                    iceberg_type: iceberg_type__,
9719                })
9720            }
9721        }
9722        deserializer.deserialize_struct("meta.ListIcebergTablesResponse.IcebergTable", FIELDS, GeneratedVisitor)
9723    }
9724}
9725impl serde::Serialize for ListObjectDependenciesRequest {
9726    #[allow(deprecated)]
9727    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9728    where
9729        S: serde::Serializer,
9730    {
9731        use serde::ser::SerializeStruct;
9732        let len = 0;
9733        let struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesRequest", len)?;
9734        struct_ser.end()
9735    }
9736}
9737impl<'de> serde::Deserialize<'de> for ListObjectDependenciesRequest {
9738    #[allow(deprecated)]
9739    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9740    where
9741        D: serde::Deserializer<'de>,
9742    {
9743        const FIELDS: &[&str] = &[
9744        ];
9745
9746        #[allow(clippy::enum_variant_names)]
9747        enum GeneratedField {
9748        }
9749        impl<'de> serde::Deserialize<'de> for GeneratedField {
9750            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9751            where
9752                D: serde::Deserializer<'de>,
9753            {
9754                struct GeneratedVisitor;
9755
9756                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9757                    type Value = GeneratedField;
9758
9759                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9760                        write!(formatter, "expected one of: {:?}", &FIELDS)
9761                    }
9762
9763                    #[allow(unused_variables)]
9764                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9765                    where
9766                        E: serde::de::Error,
9767                    {
9768                            Err(serde::de::Error::unknown_field(value, FIELDS))
9769                    }
9770                }
9771                deserializer.deserialize_identifier(GeneratedVisitor)
9772            }
9773        }
9774        struct GeneratedVisitor;
9775        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9776            type Value = ListObjectDependenciesRequest;
9777
9778            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9779                formatter.write_str("struct meta.ListObjectDependenciesRequest")
9780            }
9781
9782            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesRequest, V::Error>
9783                where
9784                    V: serde::de::MapAccess<'de>,
9785            {
9786                while map_.next_key::<GeneratedField>()?.is_some() {
9787                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9788                }
9789                Ok(ListObjectDependenciesRequest {
9790                })
9791            }
9792        }
9793        deserializer.deserialize_struct("meta.ListObjectDependenciesRequest", FIELDS, GeneratedVisitor)
9794    }
9795}
9796impl serde::Serialize for ListObjectDependenciesResponse {
9797    #[allow(deprecated)]
9798    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9799    where
9800        S: serde::Serializer,
9801    {
9802        use serde::ser::SerializeStruct;
9803        let mut len = 0;
9804        if !self.dependencies.is_empty() {
9805            len += 1;
9806        }
9807        let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse", len)?;
9808        if !self.dependencies.is_empty() {
9809            struct_ser.serialize_field("dependencies", &self.dependencies)?;
9810        }
9811        struct_ser.end()
9812    }
9813}
9814impl<'de> serde::Deserialize<'de> for ListObjectDependenciesResponse {
9815    #[allow(deprecated)]
9816    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9817    where
9818        D: serde::Deserializer<'de>,
9819    {
9820        const FIELDS: &[&str] = &[
9821            "dependencies",
9822        ];
9823
9824        #[allow(clippy::enum_variant_names)]
9825        enum GeneratedField {
9826            Dependencies,
9827        }
9828        impl<'de> serde::Deserialize<'de> for GeneratedField {
9829            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9830            where
9831                D: serde::Deserializer<'de>,
9832            {
9833                struct GeneratedVisitor;
9834
9835                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9836                    type Value = GeneratedField;
9837
9838                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9839                        write!(formatter, "expected one of: {:?}", &FIELDS)
9840                    }
9841
9842                    #[allow(unused_variables)]
9843                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9844                    where
9845                        E: serde::de::Error,
9846                    {
9847                        match value {
9848                            "dependencies" => Ok(GeneratedField::Dependencies),
9849                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9850                        }
9851                    }
9852                }
9853                deserializer.deserialize_identifier(GeneratedVisitor)
9854            }
9855        }
9856        struct GeneratedVisitor;
9857        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9858            type Value = ListObjectDependenciesResponse;
9859
9860            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9861                formatter.write_str("struct meta.ListObjectDependenciesResponse")
9862            }
9863
9864            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesResponse, V::Error>
9865                where
9866                    V: serde::de::MapAccess<'de>,
9867            {
9868                let mut dependencies__ = None;
9869                while let Some(k) = map_.next_key()? {
9870                    match k {
9871                        GeneratedField::Dependencies => {
9872                            if dependencies__.is_some() {
9873                                return Err(serde::de::Error::duplicate_field("dependencies"));
9874                            }
9875                            dependencies__ = Some(map_.next_value()?);
9876                        }
9877                    }
9878                }
9879                Ok(ListObjectDependenciesResponse {
9880                    dependencies: dependencies__.unwrap_or_default(),
9881                })
9882            }
9883        }
9884        deserializer.deserialize_struct("meta.ListObjectDependenciesResponse", FIELDS, GeneratedVisitor)
9885    }
9886}
9887impl serde::Serialize for list_object_dependencies_response::ObjectDependencies {
9888    #[allow(deprecated)]
9889    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9890    where
9891        S: serde::Serializer,
9892    {
9893        use serde::ser::SerializeStruct;
9894        let mut len = 0;
9895        if self.object_id != 0 {
9896            len += 1;
9897        }
9898        if self.referenced_object_id != 0 {
9899            len += 1;
9900        }
9901        let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", len)?;
9902        if self.object_id != 0 {
9903            struct_ser.serialize_field("objectId", &self.object_id)?;
9904        }
9905        if self.referenced_object_id != 0 {
9906            struct_ser.serialize_field("referencedObjectId", &self.referenced_object_id)?;
9907        }
9908        struct_ser.end()
9909    }
9910}
9911impl<'de> serde::Deserialize<'de> for list_object_dependencies_response::ObjectDependencies {
9912    #[allow(deprecated)]
9913    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9914    where
9915        D: serde::Deserializer<'de>,
9916    {
9917        const FIELDS: &[&str] = &[
9918            "object_id",
9919            "objectId",
9920            "referenced_object_id",
9921            "referencedObjectId",
9922        ];
9923
9924        #[allow(clippy::enum_variant_names)]
9925        enum GeneratedField {
9926            ObjectId,
9927            ReferencedObjectId,
9928        }
9929        impl<'de> serde::Deserialize<'de> for GeneratedField {
9930            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9931            where
9932                D: serde::Deserializer<'de>,
9933            {
9934                struct GeneratedVisitor;
9935
9936                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9937                    type Value = GeneratedField;
9938
9939                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9940                        write!(formatter, "expected one of: {:?}", &FIELDS)
9941                    }
9942
9943                    #[allow(unused_variables)]
9944                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9945                    where
9946                        E: serde::de::Error,
9947                    {
9948                        match value {
9949                            "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
9950                            "referencedObjectId" | "referenced_object_id" => Ok(GeneratedField::ReferencedObjectId),
9951                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9952                        }
9953                    }
9954                }
9955                deserializer.deserialize_identifier(GeneratedVisitor)
9956            }
9957        }
9958        struct GeneratedVisitor;
9959        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9960            type Value = list_object_dependencies_response::ObjectDependencies;
9961
9962            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9963                formatter.write_str("struct meta.ListObjectDependenciesResponse.ObjectDependencies")
9964            }
9965
9966            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_object_dependencies_response::ObjectDependencies, V::Error>
9967                where
9968                    V: serde::de::MapAccess<'de>,
9969            {
9970                let mut object_id__ = None;
9971                let mut referenced_object_id__ = None;
9972                while let Some(k) = map_.next_key()? {
9973                    match k {
9974                        GeneratedField::ObjectId => {
9975                            if object_id__.is_some() {
9976                                return Err(serde::de::Error::duplicate_field("objectId"));
9977                            }
9978                            object_id__ = 
9979                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9980                            ;
9981                        }
9982                        GeneratedField::ReferencedObjectId => {
9983                            if referenced_object_id__.is_some() {
9984                                return Err(serde::de::Error::duplicate_field("referencedObjectId"));
9985                            }
9986                            referenced_object_id__ = 
9987                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9988                            ;
9989                        }
9990                    }
9991                }
9992                Ok(list_object_dependencies_response::ObjectDependencies {
9993                    object_id: object_id__.unwrap_or_default(),
9994                    referenced_object_id: referenced_object_id__.unwrap_or_default(),
9995                })
9996            }
9997        }
9998        deserializer.deserialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", FIELDS, GeneratedVisitor)
9999    }
10000}
10001impl serde::Serialize for ListRateLimitsRequest {
10002    #[allow(deprecated)]
10003    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10004    where
10005        S: serde::Serializer,
10006    {
10007        use serde::ser::SerializeStruct;
10008        let len = 0;
10009        let struct_ser = serializer.serialize_struct("meta.ListRateLimitsRequest", len)?;
10010        struct_ser.end()
10011    }
10012}
10013impl<'de> serde::Deserialize<'de> for ListRateLimitsRequest {
10014    #[allow(deprecated)]
10015    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10016    where
10017        D: serde::Deserializer<'de>,
10018    {
10019        const FIELDS: &[&str] = &[
10020        ];
10021
10022        #[allow(clippy::enum_variant_names)]
10023        enum GeneratedField {
10024        }
10025        impl<'de> serde::Deserialize<'de> for GeneratedField {
10026            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10027            where
10028                D: serde::Deserializer<'de>,
10029            {
10030                struct GeneratedVisitor;
10031
10032                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10033                    type Value = GeneratedField;
10034
10035                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10036                        write!(formatter, "expected one of: {:?}", &FIELDS)
10037                    }
10038
10039                    #[allow(unused_variables)]
10040                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10041                    where
10042                        E: serde::de::Error,
10043                    {
10044                            Err(serde::de::Error::unknown_field(value, FIELDS))
10045                    }
10046                }
10047                deserializer.deserialize_identifier(GeneratedVisitor)
10048            }
10049        }
10050        struct GeneratedVisitor;
10051        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10052            type Value = ListRateLimitsRequest;
10053
10054            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10055                formatter.write_str("struct meta.ListRateLimitsRequest")
10056            }
10057
10058            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsRequest, V::Error>
10059                where
10060                    V: serde::de::MapAccess<'de>,
10061            {
10062                while map_.next_key::<GeneratedField>()?.is_some() {
10063                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10064                }
10065                Ok(ListRateLimitsRequest {
10066                })
10067            }
10068        }
10069        deserializer.deserialize_struct("meta.ListRateLimitsRequest", FIELDS, GeneratedVisitor)
10070    }
10071}
10072impl serde::Serialize for ListRateLimitsResponse {
10073    #[allow(deprecated)]
10074    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10075    where
10076        S: serde::Serializer,
10077    {
10078        use serde::ser::SerializeStruct;
10079        let mut len = 0;
10080        if !self.rate_limits.is_empty() {
10081            len += 1;
10082        }
10083        let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse", len)?;
10084        if !self.rate_limits.is_empty() {
10085            struct_ser.serialize_field("rateLimits", &self.rate_limits)?;
10086        }
10087        struct_ser.end()
10088    }
10089}
10090impl<'de> serde::Deserialize<'de> for ListRateLimitsResponse {
10091    #[allow(deprecated)]
10092    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10093    where
10094        D: serde::Deserializer<'de>,
10095    {
10096        const FIELDS: &[&str] = &[
10097            "rate_limits",
10098            "rateLimits",
10099        ];
10100
10101        #[allow(clippy::enum_variant_names)]
10102        enum GeneratedField {
10103            RateLimits,
10104        }
10105        impl<'de> serde::Deserialize<'de> for GeneratedField {
10106            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10107            where
10108                D: serde::Deserializer<'de>,
10109            {
10110                struct GeneratedVisitor;
10111
10112                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10113                    type Value = GeneratedField;
10114
10115                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10116                        write!(formatter, "expected one of: {:?}", &FIELDS)
10117                    }
10118
10119                    #[allow(unused_variables)]
10120                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10121                    where
10122                        E: serde::de::Error,
10123                    {
10124                        match value {
10125                            "rateLimits" | "rate_limits" => Ok(GeneratedField::RateLimits),
10126                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10127                        }
10128                    }
10129                }
10130                deserializer.deserialize_identifier(GeneratedVisitor)
10131            }
10132        }
10133        struct GeneratedVisitor;
10134        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10135            type Value = ListRateLimitsResponse;
10136
10137            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10138                formatter.write_str("struct meta.ListRateLimitsResponse")
10139            }
10140
10141            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsResponse, V::Error>
10142                where
10143                    V: serde::de::MapAccess<'de>,
10144            {
10145                let mut rate_limits__ = None;
10146                while let Some(k) = map_.next_key()? {
10147                    match k {
10148                        GeneratedField::RateLimits => {
10149                            if rate_limits__.is_some() {
10150                                return Err(serde::de::Error::duplicate_field("rateLimits"));
10151                            }
10152                            rate_limits__ = Some(map_.next_value()?);
10153                        }
10154                    }
10155                }
10156                Ok(ListRateLimitsResponse {
10157                    rate_limits: rate_limits__.unwrap_or_default(),
10158                })
10159            }
10160        }
10161        deserializer.deserialize_struct("meta.ListRateLimitsResponse", FIELDS, GeneratedVisitor)
10162    }
10163}
10164impl serde::Serialize for list_rate_limits_response::RateLimitInfo {
10165    #[allow(deprecated)]
10166    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10167    where
10168        S: serde::Serializer,
10169    {
10170        use serde::ser::SerializeStruct;
10171        let mut len = 0;
10172        if self.fragment_id != 0 {
10173            len += 1;
10174        }
10175        if self.job_id != 0 {
10176            len += 1;
10177        }
10178        if self.fragment_type_mask != 0 {
10179            len += 1;
10180        }
10181        if self.rate_limit != 0 {
10182            len += 1;
10183        }
10184        if !self.node_name.is_empty() {
10185            len += 1;
10186        }
10187        let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", len)?;
10188        if self.fragment_id != 0 {
10189            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10190        }
10191        if self.job_id != 0 {
10192            struct_ser.serialize_field("jobId", &self.job_id)?;
10193        }
10194        if self.fragment_type_mask != 0 {
10195            struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
10196        }
10197        if self.rate_limit != 0 {
10198            struct_ser.serialize_field("rateLimit", &self.rate_limit)?;
10199        }
10200        if !self.node_name.is_empty() {
10201            struct_ser.serialize_field("nodeName", &self.node_name)?;
10202        }
10203        struct_ser.end()
10204    }
10205}
10206impl<'de> serde::Deserialize<'de> for list_rate_limits_response::RateLimitInfo {
10207    #[allow(deprecated)]
10208    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10209    where
10210        D: serde::Deserializer<'de>,
10211    {
10212        const FIELDS: &[&str] = &[
10213            "fragment_id",
10214            "fragmentId",
10215            "job_id",
10216            "jobId",
10217            "fragment_type_mask",
10218            "fragmentTypeMask",
10219            "rate_limit",
10220            "rateLimit",
10221            "node_name",
10222            "nodeName",
10223        ];
10224
10225        #[allow(clippy::enum_variant_names)]
10226        enum GeneratedField {
10227            FragmentId,
10228            JobId,
10229            FragmentTypeMask,
10230            RateLimit,
10231            NodeName,
10232        }
10233        impl<'de> serde::Deserialize<'de> for GeneratedField {
10234            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10235            where
10236                D: serde::Deserializer<'de>,
10237            {
10238                struct GeneratedVisitor;
10239
10240                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10241                    type Value = GeneratedField;
10242
10243                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10244                        write!(formatter, "expected one of: {:?}", &FIELDS)
10245                    }
10246
10247                    #[allow(unused_variables)]
10248                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10249                    where
10250                        E: serde::de::Error,
10251                    {
10252                        match value {
10253                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10254                            "jobId" | "job_id" => Ok(GeneratedField::JobId),
10255                            "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
10256                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10257                            "nodeName" | "node_name" => Ok(GeneratedField::NodeName),
10258                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10259                        }
10260                    }
10261                }
10262                deserializer.deserialize_identifier(GeneratedVisitor)
10263            }
10264        }
10265        struct GeneratedVisitor;
10266        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10267            type Value = list_rate_limits_response::RateLimitInfo;
10268
10269            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10270                formatter.write_str("struct meta.ListRateLimitsResponse.RateLimitInfo")
10271            }
10272
10273            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_rate_limits_response::RateLimitInfo, V::Error>
10274                where
10275                    V: serde::de::MapAccess<'de>,
10276            {
10277                let mut fragment_id__ = None;
10278                let mut job_id__ = None;
10279                let mut fragment_type_mask__ = None;
10280                let mut rate_limit__ = None;
10281                let mut node_name__ = None;
10282                while let Some(k) = map_.next_key()? {
10283                    match k {
10284                        GeneratedField::FragmentId => {
10285                            if fragment_id__.is_some() {
10286                                return Err(serde::de::Error::duplicate_field("fragmentId"));
10287                            }
10288                            fragment_id__ = 
10289                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10290                            ;
10291                        }
10292                        GeneratedField::JobId => {
10293                            if job_id__.is_some() {
10294                                return Err(serde::de::Error::duplicate_field("jobId"));
10295                            }
10296                            job_id__ = 
10297                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10298                            ;
10299                        }
10300                        GeneratedField::FragmentTypeMask => {
10301                            if fragment_type_mask__.is_some() {
10302                                return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
10303                            }
10304                            fragment_type_mask__ = 
10305                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10306                            ;
10307                        }
10308                        GeneratedField::RateLimit => {
10309                            if rate_limit__.is_some() {
10310                                return Err(serde::de::Error::duplicate_field("rateLimit"));
10311                            }
10312                            rate_limit__ = 
10313                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10314                            ;
10315                        }
10316                        GeneratedField::NodeName => {
10317                            if node_name__.is_some() {
10318                                return Err(serde::de::Error::duplicate_field("nodeName"));
10319                            }
10320                            node_name__ = Some(map_.next_value()?);
10321                        }
10322                    }
10323                }
10324                Ok(list_rate_limits_response::RateLimitInfo {
10325                    fragment_id: fragment_id__.unwrap_or_default(),
10326                    job_id: job_id__.unwrap_or_default(),
10327                    fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
10328                    rate_limit: rate_limit__.unwrap_or_default(),
10329                    node_name: node_name__.unwrap_or_default(),
10330                })
10331            }
10332        }
10333        deserializer.deserialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", FIELDS, GeneratedVisitor)
10334    }
10335}
10336impl serde::Serialize for ListStreamingJobStatesRequest {
10337    #[allow(deprecated)]
10338    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10339    where
10340        S: serde::Serializer,
10341    {
10342        use serde::ser::SerializeStruct;
10343        let len = 0;
10344        let struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesRequest", len)?;
10345        struct_ser.end()
10346    }
10347}
10348impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesRequest {
10349    #[allow(deprecated)]
10350    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10351    where
10352        D: serde::Deserializer<'de>,
10353    {
10354        const FIELDS: &[&str] = &[
10355        ];
10356
10357        #[allow(clippy::enum_variant_names)]
10358        enum GeneratedField {
10359        }
10360        impl<'de> serde::Deserialize<'de> for GeneratedField {
10361            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10362            where
10363                D: serde::Deserializer<'de>,
10364            {
10365                struct GeneratedVisitor;
10366
10367                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10368                    type Value = GeneratedField;
10369
10370                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10371                        write!(formatter, "expected one of: {:?}", &FIELDS)
10372                    }
10373
10374                    #[allow(unused_variables)]
10375                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10376                    where
10377                        E: serde::de::Error,
10378                    {
10379                            Err(serde::de::Error::unknown_field(value, FIELDS))
10380                    }
10381                }
10382                deserializer.deserialize_identifier(GeneratedVisitor)
10383            }
10384        }
10385        struct GeneratedVisitor;
10386        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10387            type Value = ListStreamingJobStatesRequest;
10388
10389            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10390                formatter.write_str("struct meta.ListStreamingJobStatesRequest")
10391            }
10392
10393            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesRequest, V::Error>
10394                where
10395                    V: serde::de::MapAccess<'de>,
10396            {
10397                while map_.next_key::<GeneratedField>()?.is_some() {
10398                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10399                }
10400                Ok(ListStreamingJobStatesRequest {
10401                })
10402            }
10403        }
10404        deserializer.deserialize_struct("meta.ListStreamingJobStatesRequest", FIELDS, GeneratedVisitor)
10405    }
10406}
10407impl serde::Serialize for ListStreamingJobStatesResponse {
10408    #[allow(deprecated)]
10409    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10410    where
10411        S: serde::Serializer,
10412    {
10413        use serde::ser::SerializeStruct;
10414        let mut len = 0;
10415        if !self.states.is_empty() {
10416            len += 1;
10417        }
10418        let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse", len)?;
10419        if !self.states.is_empty() {
10420            struct_ser.serialize_field("states", &self.states)?;
10421        }
10422        struct_ser.end()
10423    }
10424}
10425impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesResponse {
10426    #[allow(deprecated)]
10427    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10428    where
10429        D: serde::Deserializer<'de>,
10430    {
10431        const FIELDS: &[&str] = &[
10432            "states",
10433        ];
10434
10435        #[allow(clippy::enum_variant_names)]
10436        enum GeneratedField {
10437            States,
10438        }
10439        impl<'de> serde::Deserialize<'de> for GeneratedField {
10440            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10441            where
10442                D: serde::Deserializer<'de>,
10443            {
10444                struct GeneratedVisitor;
10445
10446                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10447                    type Value = GeneratedField;
10448
10449                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10450                        write!(formatter, "expected one of: {:?}", &FIELDS)
10451                    }
10452
10453                    #[allow(unused_variables)]
10454                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10455                    where
10456                        E: serde::de::Error,
10457                    {
10458                        match value {
10459                            "states" => Ok(GeneratedField::States),
10460                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10461                        }
10462                    }
10463                }
10464                deserializer.deserialize_identifier(GeneratedVisitor)
10465            }
10466        }
10467        struct GeneratedVisitor;
10468        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10469            type Value = ListStreamingJobStatesResponse;
10470
10471            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10472                formatter.write_str("struct meta.ListStreamingJobStatesResponse")
10473            }
10474
10475            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesResponse, V::Error>
10476                where
10477                    V: serde::de::MapAccess<'de>,
10478            {
10479                let mut states__ = None;
10480                while let Some(k) = map_.next_key()? {
10481                    match k {
10482                        GeneratedField::States => {
10483                            if states__.is_some() {
10484                                return Err(serde::de::Error::duplicate_field("states"));
10485                            }
10486                            states__ = Some(map_.next_value()?);
10487                        }
10488                    }
10489                }
10490                Ok(ListStreamingJobStatesResponse {
10491                    states: states__.unwrap_or_default(),
10492                })
10493            }
10494        }
10495        deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse", FIELDS, GeneratedVisitor)
10496    }
10497}
10498impl serde::Serialize for list_streaming_job_states_response::StreamingJobState {
10499    #[allow(deprecated)]
10500    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10501    where
10502        S: serde::Serializer,
10503    {
10504        use serde::ser::SerializeStruct;
10505        let mut len = 0;
10506        if self.table_id != 0 {
10507            len += 1;
10508        }
10509        if self.state != 0 {
10510            len += 1;
10511        }
10512        if self.parallelism.is_some() {
10513            len += 1;
10514        }
10515        if self.max_parallelism != 0 {
10516            len += 1;
10517        }
10518        if !self.name.is_empty() {
10519            len += 1;
10520        }
10521        if !self.resource_group.is_empty() {
10522            len += 1;
10523        }
10524        if self.database_id != 0 {
10525            len += 1;
10526        }
10527        if self.schema_id != 0 {
10528            len += 1;
10529        }
10530        let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
10531        if self.table_id != 0 {
10532            struct_ser.serialize_field("tableId", &self.table_id)?;
10533        }
10534        if self.state != 0 {
10535            let v = table_fragments::State::try_from(self.state)
10536                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
10537            struct_ser.serialize_field("state", &v)?;
10538        }
10539        if let Some(v) = self.parallelism.as_ref() {
10540            struct_ser.serialize_field("parallelism", v)?;
10541        }
10542        if self.max_parallelism != 0 {
10543            struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10544        }
10545        if !self.name.is_empty() {
10546            struct_ser.serialize_field("name", &self.name)?;
10547        }
10548        if !self.resource_group.is_empty() {
10549            struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
10550        }
10551        if self.database_id != 0 {
10552            struct_ser.serialize_field("databaseId", &self.database_id)?;
10553        }
10554        if self.schema_id != 0 {
10555            struct_ser.serialize_field("schemaId", &self.schema_id)?;
10556        }
10557        struct_ser.end()
10558    }
10559}
10560impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
10561    #[allow(deprecated)]
10562    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10563    where
10564        D: serde::Deserializer<'de>,
10565    {
10566        const FIELDS: &[&str] = &[
10567            "table_id",
10568            "tableId",
10569            "state",
10570            "parallelism",
10571            "max_parallelism",
10572            "maxParallelism",
10573            "name",
10574            "resource_group",
10575            "resourceGroup",
10576            "database_id",
10577            "databaseId",
10578            "schema_id",
10579            "schemaId",
10580        ];
10581
10582        #[allow(clippy::enum_variant_names)]
10583        enum GeneratedField {
10584            TableId,
10585            State,
10586            Parallelism,
10587            MaxParallelism,
10588            Name,
10589            ResourceGroup,
10590            DatabaseId,
10591            SchemaId,
10592        }
10593        impl<'de> serde::Deserialize<'de> for GeneratedField {
10594            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10595            where
10596                D: serde::Deserializer<'de>,
10597            {
10598                struct GeneratedVisitor;
10599
10600                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10601                    type Value = GeneratedField;
10602
10603                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10604                        write!(formatter, "expected one of: {:?}", &FIELDS)
10605                    }
10606
10607                    #[allow(unused_variables)]
10608                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10609                    where
10610                        E: serde::de::Error,
10611                    {
10612                        match value {
10613                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
10614                            "state" => Ok(GeneratedField::State),
10615                            "parallelism" => Ok(GeneratedField::Parallelism),
10616                            "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
10617                            "name" => Ok(GeneratedField::Name),
10618                            "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
10619                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
10620                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
10621                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10622                        }
10623                    }
10624                }
10625                deserializer.deserialize_identifier(GeneratedVisitor)
10626            }
10627        }
10628        struct GeneratedVisitor;
10629        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10630            type Value = list_streaming_job_states_response::StreamingJobState;
10631
10632            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10633                formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
10634            }
10635
10636            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
10637                where
10638                    V: serde::de::MapAccess<'de>,
10639            {
10640                let mut table_id__ = None;
10641                let mut state__ = None;
10642                let mut parallelism__ = None;
10643                let mut max_parallelism__ = None;
10644                let mut name__ = None;
10645                let mut resource_group__ = None;
10646                let mut database_id__ = None;
10647                let mut schema_id__ = None;
10648                while let Some(k) = map_.next_key()? {
10649                    match k {
10650                        GeneratedField::TableId => {
10651                            if table_id__.is_some() {
10652                                return Err(serde::de::Error::duplicate_field("tableId"));
10653                            }
10654                            table_id__ = 
10655                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10656                            ;
10657                        }
10658                        GeneratedField::State => {
10659                            if state__.is_some() {
10660                                return Err(serde::de::Error::duplicate_field("state"));
10661                            }
10662                            state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
10663                        }
10664                        GeneratedField::Parallelism => {
10665                            if parallelism__.is_some() {
10666                                return Err(serde::de::Error::duplicate_field("parallelism"));
10667                            }
10668                            parallelism__ = map_.next_value()?;
10669                        }
10670                        GeneratedField::MaxParallelism => {
10671                            if max_parallelism__.is_some() {
10672                                return Err(serde::de::Error::duplicate_field("maxParallelism"));
10673                            }
10674                            max_parallelism__ = 
10675                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10676                            ;
10677                        }
10678                        GeneratedField::Name => {
10679                            if name__.is_some() {
10680                                return Err(serde::de::Error::duplicate_field("name"));
10681                            }
10682                            name__ = Some(map_.next_value()?);
10683                        }
10684                        GeneratedField::ResourceGroup => {
10685                            if resource_group__.is_some() {
10686                                return Err(serde::de::Error::duplicate_field("resourceGroup"));
10687                            }
10688                            resource_group__ = Some(map_.next_value()?);
10689                        }
10690                        GeneratedField::DatabaseId => {
10691                            if database_id__.is_some() {
10692                                return Err(serde::de::Error::duplicate_field("databaseId"));
10693                            }
10694                            database_id__ = 
10695                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10696                            ;
10697                        }
10698                        GeneratedField::SchemaId => {
10699                            if schema_id__.is_some() {
10700                                return Err(serde::de::Error::duplicate_field("schemaId"));
10701                            }
10702                            schema_id__ = 
10703                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10704                            ;
10705                        }
10706                    }
10707                }
10708                Ok(list_streaming_job_states_response::StreamingJobState {
10709                    table_id: table_id__.unwrap_or_default(),
10710                    state: state__.unwrap_or_default(),
10711                    parallelism: parallelism__,
10712                    max_parallelism: max_parallelism__.unwrap_or_default(),
10713                    name: name__.unwrap_or_default(),
10714                    resource_group: resource_group__.unwrap_or_default(),
10715                    database_id: database_id__.unwrap_or_default(),
10716                    schema_id: schema_id__.unwrap_or_default(),
10717                })
10718            }
10719        }
10720        deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
10721    }
10722}
10723impl serde::Serialize for ListTableFragmentsRequest {
10724    #[allow(deprecated)]
10725    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10726    where
10727        S: serde::Serializer,
10728    {
10729        use serde::ser::SerializeStruct;
10730        let mut len = 0;
10731        if !self.table_ids.is_empty() {
10732            len += 1;
10733        }
10734        let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
10735        if !self.table_ids.is_empty() {
10736            struct_ser.serialize_field("tableIds", &self.table_ids)?;
10737        }
10738        struct_ser.end()
10739    }
10740}
10741impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
10742    #[allow(deprecated)]
10743    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10744    where
10745        D: serde::Deserializer<'de>,
10746    {
10747        const FIELDS: &[&str] = &[
10748            "table_ids",
10749            "tableIds",
10750        ];
10751
10752        #[allow(clippy::enum_variant_names)]
10753        enum GeneratedField {
10754            TableIds,
10755        }
10756        impl<'de> serde::Deserialize<'de> for GeneratedField {
10757            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10758            where
10759                D: serde::Deserializer<'de>,
10760            {
10761                struct GeneratedVisitor;
10762
10763                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10764                    type Value = GeneratedField;
10765
10766                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10767                        write!(formatter, "expected one of: {:?}", &FIELDS)
10768                    }
10769
10770                    #[allow(unused_variables)]
10771                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10772                    where
10773                        E: serde::de::Error,
10774                    {
10775                        match value {
10776                            "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
10777                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10778                        }
10779                    }
10780                }
10781                deserializer.deserialize_identifier(GeneratedVisitor)
10782            }
10783        }
10784        struct GeneratedVisitor;
10785        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10786            type Value = ListTableFragmentsRequest;
10787
10788            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10789                formatter.write_str("struct meta.ListTableFragmentsRequest")
10790            }
10791
10792            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
10793                where
10794                    V: serde::de::MapAccess<'de>,
10795            {
10796                let mut table_ids__ = None;
10797                while let Some(k) = map_.next_key()? {
10798                    match k {
10799                        GeneratedField::TableIds => {
10800                            if table_ids__.is_some() {
10801                                return Err(serde::de::Error::duplicate_field("tableIds"));
10802                            }
10803                            table_ids__ = 
10804                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10805                                    .into_iter().map(|x| x.0).collect())
10806                            ;
10807                        }
10808                    }
10809                }
10810                Ok(ListTableFragmentsRequest {
10811                    table_ids: table_ids__.unwrap_or_default(),
10812                })
10813            }
10814        }
10815        deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
10816    }
10817}
10818impl serde::Serialize for ListTableFragmentsResponse {
10819    #[allow(deprecated)]
10820    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10821    where
10822        S: serde::Serializer,
10823    {
10824        use serde::ser::SerializeStruct;
10825        let mut len = 0;
10826        if !self.table_fragments.is_empty() {
10827            len += 1;
10828        }
10829        let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
10830        if !self.table_fragments.is_empty() {
10831            struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
10832        }
10833        struct_ser.end()
10834    }
10835}
10836impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
10837    #[allow(deprecated)]
10838    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10839    where
10840        D: serde::Deserializer<'de>,
10841    {
10842        const FIELDS: &[&str] = &[
10843            "table_fragments",
10844            "tableFragments",
10845        ];
10846
10847        #[allow(clippy::enum_variant_names)]
10848        enum GeneratedField {
10849            TableFragments,
10850        }
10851        impl<'de> serde::Deserialize<'de> for GeneratedField {
10852            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10853            where
10854                D: serde::Deserializer<'de>,
10855            {
10856                struct GeneratedVisitor;
10857
10858                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10859                    type Value = GeneratedField;
10860
10861                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10862                        write!(formatter, "expected one of: {:?}", &FIELDS)
10863                    }
10864
10865                    #[allow(unused_variables)]
10866                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10867                    where
10868                        E: serde::de::Error,
10869                    {
10870                        match value {
10871                            "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
10872                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10873                        }
10874                    }
10875                }
10876                deserializer.deserialize_identifier(GeneratedVisitor)
10877            }
10878        }
10879        struct GeneratedVisitor;
10880        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10881            type Value = ListTableFragmentsResponse;
10882
10883            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10884                formatter.write_str("struct meta.ListTableFragmentsResponse")
10885            }
10886
10887            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
10888                where
10889                    V: serde::de::MapAccess<'de>,
10890            {
10891                let mut table_fragments__ = None;
10892                while let Some(k) = map_.next_key()? {
10893                    match k {
10894                        GeneratedField::TableFragments => {
10895                            if table_fragments__.is_some() {
10896                                return Err(serde::de::Error::duplicate_field("tableFragments"));
10897                            }
10898                            table_fragments__ = Some(
10899                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10900                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
10901                            );
10902                        }
10903                    }
10904                }
10905                Ok(ListTableFragmentsResponse {
10906                    table_fragments: table_fragments__.unwrap_or_default(),
10907                })
10908            }
10909        }
10910        deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
10911    }
10912}
10913impl serde::Serialize for list_table_fragments_response::ActorInfo {
10914    #[allow(deprecated)]
10915    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10916    where
10917        S: serde::Serializer,
10918    {
10919        use serde::ser::SerializeStruct;
10920        let mut len = 0;
10921        if self.id != 0 {
10922            len += 1;
10923        }
10924        if self.node.is_some() {
10925            len += 1;
10926        }
10927        if !self.dispatcher.is_empty() {
10928            len += 1;
10929        }
10930        let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
10931        if self.id != 0 {
10932            struct_ser.serialize_field("id", &self.id)?;
10933        }
10934        if let Some(v) = self.node.as_ref() {
10935            struct_ser.serialize_field("node", v)?;
10936        }
10937        if !self.dispatcher.is_empty() {
10938            struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
10939        }
10940        struct_ser.end()
10941    }
10942}
10943impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
10944    #[allow(deprecated)]
10945    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10946    where
10947        D: serde::Deserializer<'de>,
10948    {
10949        const FIELDS: &[&str] = &[
10950            "id",
10951            "node",
10952            "dispatcher",
10953        ];
10954
10955        #[allow(clippy::enum_variant_names)]
10956        enum GeneratedField {
10957            Id,
10958            Node,
10959            Dispatcher,
10960        }
10961        impl<'de> serde::Deserialize<'de> for GeneratedField {
10962            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10963            where
10964                D: serde::Deserializer<'de>,
10965            {
10966                struct GeneratedVisitor;
10967
10968                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10969                    type Value = GeneratedField;
10970
10971                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10972                        write!(formatter, "expected one of: {:?}", &FIELDS)
10973                    }
10974
10975                    #[allow(unused_variables)]
10976                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10977                    where
10978                        E: serde::de::Error,
10979                    {
10980                        match value {
10981                            "id" => Ok(GeneratedField::Id),
10982                            "node" => Ok(GeneratedField::Node),
10983                            "dispatcher" => Ok(GeneratedField::Dispatcher),
10984                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10985                        }
10986                    }
10987                }
10988                deserializer.deserialize_identifier(GeneratedVisitor)
10989            }
10990        }
10991        struct GeneratedVisitor;
10992        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10993            type Value = list_table_fragments_response::ActorInfo;
10994
10995            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10996                formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
10997            }
10998
10999            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
11000                where
11001                    V: serde::de::MapAccess<'de>,
11002            {
11003                let mut id__ = None;
11004                let mut node__ = None;
11005                let mut dispatcher__ = None;
11006                while let Some(k) = map_.next_key()? {
11007                    match k {
11008                        GeneratedField::Id => {
11009                            if id__.is_some() {
11010                                return Err(serde::de::Error::duplicate_field("id"));
11011                            }
11012                            id__ = 
11013                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11014                            ;
11015                        }
11016                        GeneratedField::Node => {
11017                            if node__.is_some() {
11018                                return Err(serde::de::Error::duplicate_field("node"));
11019                            }
11020                            node__ = map_.next_value()?;
11021                        }
11022                        GeneratedField::Dispatcher => {
11023                            if dispatcher__.is_some() {
11024                                return Err(serde::de::Error::duplicate_field("dispatcher"));
11025                            }
11026                            dispatcher__ = Some(map_.next_value()?);
11027                        }
11028                    }
11029                }
11030                Ok(list_table_fragments_response::ActorInfo {
11031                    id: id__.unwrap_or_default(),
11032                    node: node__,
11033                    dispatcher: dispatcher__.unwrap_or_default(),
11034                })
11035            }
11036        }
11037        deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
11038    }
11039}
11040impl serde::Serialize for list_table_fragments_response::FragmentInfo {
11041    #[allow(deprecated)]
11042    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11043    where
11044        S: serde::Serializer,
11045    {
11046        use serde::ser::SerializeStruct;
11047        let mut len = 0;
11048        if self.id != 0 {
11049            len += 1;
11050        }
11051        if !self.actors.is_empty() {
11052            len += 1;
11053        }
11054        let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
11055        if self.id != 0 {
11056            struct_ser.serialize_field("id", &self.id)?;
11057        }
11058        if !self.actors.is_empty() {
11059            struct_ser.serialize_field("actors", &self.actors)?;
11060        }
11061        struct_ser.end()
11062    }
11063}
11064impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
11065    #[allow(deprecated)]
11066    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11067    where
11068        D: serde::Deserializer<'de>,
11069    {
11070        const FIELDS: &[&str] = &[
11071            "id",
11072            "actors",
11073        ];
11074
11075        #[allow(clippy::enum_variant_names)]
11076        enum GeneratedField {
11077            Id,
11078            Actors,
11079        }
11080        impl<'de> serde::Deserialize<'de> for GeneratedField {
11081            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11082            where
11083                D: serde::Deserializer<'de>,
11084            {
11085                struct GeneratedVisitor;
11086
11087                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11088                    type Value = GeneratedField;
11089
11090                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11091                        write!(formatter, "expected one of: {:?}", &FIELDS)
11092                    }
11093
11094                    #[allow(unused_variables)]
11095                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11096                    where
11097                        E: serde::de::Error,
11098                    {
11099                        match value {
11100                            "id" => Ok(GeneratedField::Id),
11101                            "actors" => Ok(GeneratedField::Actors),
11102                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11103                        }
11104                    }
11105                }
11106                deserializer.deserialize_identifier(GeneratedVisitor)
11107            }
11108        }
11109        struct GeneratedVisitor;
11110        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11111            type Value = list_table_fragments_response::FragmentInfo;
11112
11113            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11114                formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
11115            }
11116
11117            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
11118                where
11119                    V: serde::de::MapAccess<'de>,
11120            {
11121                let mut id__ = None;
11122                let mut actors__ = None;
11123                while let Some(k) = map_.next_key()? {
11124                    match k {
11125                        GeneratedField::Id => {
11126                            if id__.is_some() {
11127                                return Err(serde::de::Error::duplicate_field("id"));
11128                            }
11129                            id__ = 
11130                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11131                            ;
11132                        }
11133                        GeneratedField::Actors => {
11134                            if actors__.is_some() {
11135                                return Err(serde::de::Error::duplicate_field("actors"));
11136                            }
11137                            actors__ = Some(map_.next_value()?);
11138                        }
11139                    }
11140                }
11141                Ok(list_table_fragments_response::FragmentInfo {
11142                    id: id__.unwrap_or_default(),
11143                    actors: actors__.unwrap_or_default(),
11144                })
11145            }
11146        }
11147        deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
11148    }
11149}
11150impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
11151    #[allow(deprecated)]
11152    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11153    where
11154        S: serde::Serializer,
11155    {
11156        use serde::ser::SerializeStruct;
11157        let mut len = 0;
11158        if !self.fragments.is_empty() {
11159            len += 1;
11160        }
11161        if self.ctx.is_some() {
11162            len += 1;
11163        }
11164        let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
11165        if !self.fragments.is_empty() {
11166            struct_ser.serialize_field("fragments", &self.fragments)?;
11167        }
11168        if let Some(v) = self.ctx.as_ref() {
11169            struct_ser.serialize_field("ctx", v)?;
11170        }
11171        struct_ser.end()
11172    }
11173}
11174impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
11175    #[allow(deprecated)]
11176    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11177    where
11178        D: serde::Deserializer<'de>,
11179    {
11180        const FIELDS: &[&str] = &[
11181            "fragments",
11182            "ctx",
11183        ];
11184
11185        #[allow(clippy::enum_variant_names)]
11186        enum GeneratedField {
11187            Fragments,
11188            Ctx,
11189        }
11190        impl<'de> serde::Deserialize<'de> for GeneratedField {
11191            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11192            where
11193                D: serde::Deserializer<'de>,
11194            {
11195                struct GeneratedVisitor;
11196
11197                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11198                    type Value = GeneratedField;
11199
11200                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11201                        write!(formatter, "expected one of: {:?}", &FIELDS)
11202                    }
11203
11204                    #[allow(unused_variables)]
11205                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11206                    where
11207                        E: serde::de::Error,
11208                    {
11209                        match value {
11210                            "fragments" => Ok(GeneratedField::Fragments),
11211                            "ctx" => Ok(GeneratedField::Ctx),
11212                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11213                        }
11214                    }
11215                }
11216                deserializer.deserialize_identifier(GeneratedVisitor)
11217            }
11218        }
11219        struct GeneratedVisitor;
11220        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11221            type Value = list_table_fragments_response::TableFragmentInfo;
11222
11223            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11224                formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
11225            }
11226
11227            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
11228                where
11229                    V: serde::de::MapAccess<'de>,
11230            {
11231                let mut fragments__ = None;
11232                let mut ctx__ = None;
11233                while let Some(k) = map_.next_key()? {
11234                    match k {
11235                        GeneratedField::Fragments => {
11236                            if fragments__.is_some() {
11237                                return Err(serde::de::Error::duplicate_field("fragments"));
11238                            }
11239                            fragments__ = Some(map_.next_value()?);
11240                        }
11241                        GeneratedField::Ctx => {
11242                            if ctx__.is_some() {
11243                                return Err(serde::de::Error::duplicate_field("ctx"));
11244                            }
11245                            ctx__ = map_.next_value()?;
11246                        }
11247                    }
11248                }
11249                Ok(list_table_fragments_response::TableFragmentInfo {
11250                    fragments: fragments__.unwrap_or_default(),
11251                    ctx: ctx__,
11252                })
11253            }
11254        }
11255        deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
11256    }
11257}
11258impl serde::Serialize for MembersRequest {
11259    #[allow(deprecated)]
11260    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11261    where
11262        S: serde::Serializer,
11263    {
11264        use serde::ser::SerializeStruct;
11265        let len = 0;
11266        let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
11267        struct_ser.end()
11268    }
11269}
11270impl<'de> serde::Deserialize<'de> for MembersRequest {
11271    #[allow(deprecated)]
11272    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11273    where
11274        D: serde::Deserializer<'de>,
11275    {
11276        const FIELDS: &[&str] = &[
11277        ];
11278
11279        #[allow(clippy::enum_variant_names)]
11280        enum GeneratedField {
11281        }
11282        impl<'de> serde::Deserialize<'de> for GeneratedField {
11283            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11284            where
11285                D: serde::Deserializer<'de>,
11286            {
11287                struct GeneratedVisitor;
11288
11289                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11290                    type Value = GeneratedField;
11291
11292                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11293                        write!(formatter, "expected one of: {:?}", &FIELDS)
11294                    }
11295
11296                    #[allow(unused_variables)]
11297                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11298                    where
11299                        E: serde::de::Error,
11300                    {
11301                            Err(serde::de::Error::unknown_field(value, FIELDS))
11302                    }
11303                }
11304                deserializer.deserialize_identifier(GeneratedVisitor)
11305            }
11306        }
11307        struct GeneratedVisitor;
11308        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11309            type Value = MembersRequest;
11310
11311            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11312                formatter.write_str("struct meta.MembersRequest")
11313            }
11314
11315            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
11316                where
11317                    V: serde::de::MapAccess<'de>,
11318            {
11319                while map_.next_key::<GeneratedField>()?.is_some() {
11320                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11321                }
11322                Ok(MembersRequest {
11323                })
11324            }
11325        }
11326        deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
11327    }
11328}
11329impl serde::Serialize for MembersResponse {
11330    #[allow(deprecated)]
11331    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11332    where
11333        S: serde::Serializer,
11334    {
11335        use serde::ser::SerializeStruct;
11336        let mut len = 0;
11337        if !self.members.is_empty() {
11338            len += 1;
11339        }
11340        let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
11341        if !self.members.is_empty() {
11342            struct_ser.serialize_field("members", &self.members)?;
11343        }
11344        struct_ser.end()
11345    }
11346}
11347impl<'de> serde::Deserialize<'de> for MembersResponse {
11348    #[allow(deprecated)]
11349    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11350    where
11351        D: serde::Deserializer<'de>,
11352    {
11353        const FIELDS: &[&str] = &[
11354            "members",
11355        ];
11356
11357        #[allow(clippy::enum_variant_names)]
11358        enum GeneratedField {
11359            Members,
11360        }
11361        impl<'de> serde::Deserialize<'de> for GeneratedField {
11362            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11363            where
11364                D: serde::Deserializer<'de>,
11365            {
11366                struct GeneratedVisitor;
11367
11368                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11369                    type Value = GeneratedField;
11370
11371                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11372                        write!(formatter, "expected one of: {:?}", &FIELDS)
11373                    }
11374
11375                    #[allow(unused_variables)]
11376                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11377                    where
11378                        E: serde::de::Error,
11379                    {
11380                        match value {
11381                            "members" => Ok(GeneratedField::Members),
11382                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11383                        }
11384                    }
11385                }
11386                deserializer.deserialize_identifier(GeneratedVisitor)
11387            }
11388        }
11389        struct GeneratedVisitor;
11390        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11391            type Value = MembersResponse;
11392
11393            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11394                formatter.write_str("struct meta.MembersResponse")
11395            }
11396
11397            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
11398                where
11399                    V: serde::de::MapAccess<'de>,
11400            {
11401                let mut members__ = None;
11402                while let Some(k) = map_.next_key()? {
11403                    match k {
11404                        GeneratedField::Members => {
11405                            if members__.is_some() {
11406                                return Err(serde::de::Error::duplicate_field("members"));
11407                            }
11408                            members__ = Some(map_.next_value()?);
11409                        }
11410                    }
11411                }
11412                Ok(MembersResponse {
11413                    members: members__.unwrap_or_default(),
11414                })
11415            }
11416        }
11417        deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
11418    }
11419}
11420impl serde::Serialize for MetaMember {
11421    #[allow(deprecated)]
11422    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11423    where
11424        S: serde::Serializer,
11425    {
11426        use serde::ser::SerializeStruct;
11427        let mut len = 0;
11428        if self.address.is_some() {
11429            len += 1;
11430        }
11431        if self.is_leader {
11432            len += 1;
11433        }
11434        let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
11435        if let Some(v) = self.address.as_ref() {
11436            struct_ser.serialize_field("address", v)?;
11437        }
11438        if self.is_leader {
11439            struct_ser.serialize_field("isLeader", &self.is_leader)?;
11440        }
11441        struct_ser.end()
11442    }
11443}
11444impl<'de> serde::Deserialize<'de> for MetaMember {
11445    #[allow(deprecated)]
11446    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11447    where
11448        D: serde::Deserializer<'de>,
11449    {
11450        const FIELDS: &[&str] = &[
11451            "address",
11452            "is_leader",
11453            "isLeader",
11454        ];
11455
11456        #[allow(clippy::enum_variant_names)]
11457        enum GeneratedField {
11458            Address,
11459            IsLeader,
11460        }
11461        impl<'de> serde::Deserialize<'de> for GeneratedField {
11462            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11463            where
11464                D: serde::Deserializer<'de>,
11465            {
11466                struct GeneratedVisitor;
11467
11468                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11469                    type Value = GeneratedField;
11470
11471                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11472                        write!(formatter, "expected one of: {:?}", &FIELDS)
11473                    }
11474
11475                    #[allow(unused_variables)]
11476                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11477                    where
11478                        E: serde::de::Error,
11479                    {
11480                        match value {
11481                            "address" => Ok(GeneratedField::Address),
11482                            "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
11483                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11484                        }
11485                    }
11486                }
11487                deserializer.deserialize_identifier(GeneratedVisitor)
11488            }
11489        }
11490        struct GeneratedVisitor;
11491        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11492            type Value = MetaMember;
11493
11494            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11495                formatter.write_str("struct meta.MetaMember")
11496            }
11497
11498            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
11499                where
11500                    V: serde::de::MapAccess<'de>,
11501            {
11502                let mut address__ = None;
11503                let mut is_leader__ = None;
11504                while let Some(k) = map_.next_key()? {
11505                    match k {
11506                        GeneratedField::Address => {
11507                            if address__.is_some() {
11508                                return Err(serde::de::Error::duplicate_field("address"));
11509                            }
11510                            address__ = map_.next_value()?;
11511                        }
11512                        GeneratedField::IsLeader => {
11513                            if is_leader__.is_some() {
11514                                return Err(serde::de::Error::duplicate_field("isLeader"));
11515                            }
11516                            is_leader__ = Some(map_.next_value()?);
11517                        }
11518                    }
11519                }
11520                Ok(MetaMember {
11521                    address: address__,
11522                    is_leader: is_leader__.unwrap_or_default(),
11523                })
11524            }
11525        }
11526        deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
11527    }
11528}
11529impl serde::Serialize for MetaSnapshot {
11530    #[allow(deprecated)]
11531    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11532    where
11533        S: serde::Serializer,
11534    {
11535        use serde::ser::SerializeStruct;
11536        let mut len = 0;
11537        if !self.databases.is_empty() {
11538            len += 1;
11539        }
11540        if !self.schemas.is_empty() {
11541            len += 1;
11542        }
11543        if !self.sources.is_empty() {
11544            len += 1;
11545        }
11546        if !self.sinks.is_empty() {
11547            len += 1;
11548        }
11549        if !self.tables.is_empty() {
11550            len += 1;
11551        }
11552        if !self.indexes.is_empty() {
11553            len += 1;
11554        }
11555        if !self.views.is_empty() {
11556            len += 1;
11557        }
11558        if !self.functions.is_empty() {
11559            len += 1;
11560        }
11561        if !self.connections.is_empty() {
11562            len += 1;
11563        }
11564        if !self.subscriptions.is_empty() {
11565            len += 1;
11566        }
11567        if !self.users.is_empty() {
11568            len += 1;
11569        }
11570        if self.session_params.is_some() {
11571            len += 1;
11572        }
11573        if !self.secrets.is_empty() {
11574            len += 1;
11575        }
11576        if self.compute_node_total_cpu_count != 0 {
11577            len += 1;
11578        }
11579        if !self.nodes.is_empty() {
11580            len += 1;
11581        }
11582        if self.hummock_version.is_some() {
11583            len += 1;
11584        }
11585        if self.meta_backup_manifest_id.is_some() {
11586            len += 1;
11587        }
11588        if self.hummock_write_limits.is_some() {
11589            len += 1;
11590        }
11591        if !self.streaming_worker_slot_mappings.is_empty() {
11592            len += 1;
11593        }
11594        if !self.serving_worker_slot_mappings.is_empty() {
11595            len += 1;
11596        }
11597        if self.version.is_some() {
11598            len += 1;
11599        }
11600        let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
11601        if !self.databases.is_empty() {
11602            struct_ser.serialize_field("databases", &self.databases)?;
11603        }
11604        if !self.schemas.is_empty() {
11605            struct_ser.serialize_field("schemas", &self.schemas)?;
11606        }
11607        if !self.sources.is_empty() {
11608            struct_ser.serialize_field("sources", &self.sources)?;
11609        }
11610        if !self.sinks.is_empty() {
11611            struct_ser.serialize_field("sinks", &self.sinks)?;
11612        }
11613        if !self.tables.is_empty() {
11614            struct_ser.serialize_field("tables", &self.tables)?;
11615        }
11616        if !self.indexes.is_empty() {
11617            struct_ser.serialize_field("indexes", &self.indexes)?;
11618        }
11619        if !self.views.is_empty() {
11620            struct_ser.serialize_field("views", &self.views)?;
11621        }
11622        if !self.functions.is_empty() {
11623            struct_ser.serialize_field("functions", &self.functions)?;
11624        }
11625        if !self.connections.is_empty() {
11626            struct_ser.serialize_field("connections", &self.connections)?;
11627        }
11628        if !self.subscriptions.is_empty() {
11629            struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
11630        }
11631        if !self.users.is_empty() {
11632            struct_ser.serialize_field("users", &self.users)?;
11633        }
11634        if let Some(v) = self.session_params.as_ref() {
11635            struct_ser.serialize_field("sessionParams", v)?;
11636        }
11637        if !self.secrets.is_empty() {
11638            struct_ser.serialize_field("secrets", &self.secrets)?;
11639        }
11640        if self.compute_node_total_cpu_count != 0 {
11641            #[allow(clippy::needless_borrow)]
11642            #[allow(clippy::needless_borrows_for_generic_args)]
11643            struct_ser.serialize_field("computeNodeTotalCpuCount", ToString::to_string(&self.compute_node_total_cpu_count).as_str())?;
11644        }
11645        if !self.nodes.is_empty() {
11646            struct_ser.serialize_field("nodes", &self.nodes)?;
11647        }
11648        if let Some(v) = self.hummock_version.as_ref() {
11649            struct_ser.serialize_field("hummockVersion", v)?;
11650        }
11651        if let Some(v) = self.meta_backup_manifest_id.as_ref() {
11652            struct_ser.serialize_field("metaBackupManifestId", v)?;
11653        }
11654        if let Some(v) = self.hummock_write_limits.as_ref() {
11655            struct_ser.serialize_field("hummockWriteLimits", v)?;
11656        }
11657        if !self.streaming_worker_slot_mappings.is_empty() {
11658            struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
11659        }
11660        if !self.serving_worker_slot_mappings.is_empty() {
11661            struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
11662        }
11663        if let Some(v) = self.version.as_ref() {
11664            struct_ser.serialize_field("version", v)?;
11665        }
11666        struct_ser.end()
11667    }
11668}
11669impl<'de> serde::Deserialize<'de> for MetaSnapshot {
11670    #[allow(deprecated)]
11671    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11672    where
11673        D: serde::Deserializer<'de>,
11674    {
11675        const FIELDS: &[&str] = &[
11676            "databases",
11677            "schemas",
11678            "sources",
11679            "sinks",
11680            "tables",
11681            "indexes",
11682            "views",
11683            "functions",
11684            "connections",
11685            "subscriptions",
11686            "users",
11687            "session_params",
11688            "sessionParams",
11689            "secrets",
11690            "compute_node_total_cpu_count",
11691            "computeNodeTotalCpuCount",
11692            "nodes",
11693            "hummock_version",
11694            "hummockVersion",
11695            "meta_backup_manifest_id",
11696            "metaBackupManifestId",
11697            "hummock_write_limits",
11698            "hummockWriteLimits",
11699            "streaming_worker_slot_mappings",
11700            "streamingWorkerSlotMappings",
11701            "serving_worker_slot_mappings",
11702            "servingWorkerSlotMappings",
11703            "version",
11704        ];
11705
11706        #[allow(clippy::enum_variant_names)]
11707        enum GeneratedField {
11708            Databases,
11709            Schemas,
11710            Sources,
11711            Sinks,
11712            Tables,
11713            Indexes,
11714            Views,
11715            Functions,
11716            Connections,
11717            Subscriptions,
11718            Users,
11719            SessionParams,
11720            Secrets,
11721            ComputeNodeTotalCpuCount,
11722            Nodes,
11723            HummockVersion,
11724            MetaBackupManifestId,
11725            HummockWriteLimits,
11726            StreamingWorkerSlotMappings,
11727            ServingWorkerSlotMappings,
11728            Version,
11729        }
11730        impl<'de> serde::Deserialize<'de> for GeneratedField {
11731            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11732            where
11733                D: serde::Deserializer<'de>,
11734            {
11735                struct GeneratedVisitor;
11736
11737                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11738                    type Value = GeneratedField;
11739
11740                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11741                        write!(formatter, "expected one of: {:?}", &FIELDS)
11742                    }
11743
11744                    #[allow(unused_variables)]
11745                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11746                    where
11747                        E: serde::de::Error,
11748                    {
11749                        match value {
11750                            "databases" => Ok(GeneratedField::Databases),
11751                            "schemas" => Ok(GeneratedField::Schemas),
11752                            "sources" => Ok(GeneratedField::Sources),
11753                            "sinks" => Ok(GeneratedField::Sinks),
11754                            "tables" => Ok(GeneratedField::Tables),
11755                            "indexes" => Ok(GeneratedField::Indexes),
11756                            "views" => Ok(GeneratedField::Views),
11757                            "functions" => Ok(GeneratedField::Functions),
11758                            "connections" => Ok(GeneratedField::Connections),
11759                            "subscriptions" => Ok(GeneratedField::Subscriptions),
11760                            "users" => Ok(GeneratedField::Users),
11761                            "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
11762                            "secrets" => Ok(GeneratedField::Secrets),
11763                            "computeNodeTotalCpuCount" | "compute_node_total_cpu_count" => Ok(GeneratedField::ComputeNodeTotalCpuCount),
11764                            "nodes" => Ok(GeneratedField::Nodes),
11765                            "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
11766                            "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
11767                            "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
11768                            "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
11769                            "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
11770                            "version" => Ok(GeneratedField::Version),
11771                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11772                        }
11773                    }
11774                }
11775                deserializer.deserialize_identifier(GeneratedVisitor)
11776            }
11777        }
11778        struct GeneratedVisitor;
11779        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11780            type Value = MetaSnapshot;
11781
11782            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11783                formatter.write_str("struct meta.MetaSnapshot")
11784            }
11785
11786            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
11787                where
11788                    V: serde::de::MapAccess<'de>,
11789            {
11790                let mut databases__ = None;
11791                let mut schemas__ = None;
11792                let mut sources__ = None;
11793                let mut sinks__ = None;
11794                let mut tables__ = None;
11795                let mut indexes__ = None;
11796                let mut views__ = None;
11797                let mut functions__ = None;
11798                let mut connections__ = None;
11799                let mut subscriptions__ = None;
11800                let mut users__ = None;
11801                let mut session_params__ = None;
11802                let mut secrets__ = None;
11803                let mut compute_node_total_cpu_count__ = None;
11804                let mut nodes__ = None;
11805                let mut hummock_version__ = None;
11806                let mut meta_backup_manifest_id__ = None;
11807                let mut hummock_write_limits__ = None;
11808                let mut streaming_worker_slot_mappings__ = None;
11809                let mut serving_worker_slot_mappings__ = None;
11810                let mut version__ = None;
11811                while let Some(k) = map_.next_key()? {
11812                    match k {
11813                        GeneratedField::Databases => {
11814                            if databases__.is_some() {
11815                                return Err(serde::de::Error::duplicate_field("databases"));
11816                            }
11817                            databases__ = Some(map_.next_value()?);
11818                        }
11819                        GeneratedField::Schemas => {
11820                            if schemas__.is_some() {
11821                                return Err(serde::de::Error::duplicate_field("schemas"));
11822                            }
11823                            schemas__ = Some(map_.next_value()?);
11824                        }
11825                        GeneratedField::Sources => {
11826                            if sources__.is_some() {
11827                                return Err(serde::de::Error::duplicate_field("sources"));
11828                            }
11829                            sources__ = Some(map_.next_value()?);
11830                        }
11831                        GeneratedField::Sinks => {
11832                            if sinks__.is_some() {
11833                                return Err(serde::de::Error::duplicate_field("sinks"));
11834                            }
11835                            sinks__ = Some(map_.next_value()?);
11836                        }
11837                        GeneratedField::Tables => {
11838                            if tables__.is_some() {
11839                                return Err(serde::de::Error::duplicate_field("tables"));
11840                            }
11841                            tables__ = Some(map_.next_value()?);
11842                        }
11843                        GeneratedField::Indexes => {
11844                            if indexes__.is_some() {
11845                                return Err(serde::de::Error::duplicate_field("indexes"));
11846                            }
11847                            indexes__ = Some(map_.next_value()?);
11848                        }
11849                        GeneratedField::Views => {
11850                            if views__.is_some() {
11851                                return Err(serde::de::Error::duplicate_field("views"));
11852                            }
11853                            views__ = Some(map_.next_value()?);
11854                        }
11855                        GeneratedField::Functions => {
11856                            if functions__.is_some() {
11857                                return Err(serde::de::Error::duplicate_field("functions"));
11858                            }
11859                            functions__ = Some(map_.next_value()?);
11860                        }
11861                        GeneratedField::Connections => {
11862                            if connections__.is_some() {
11863                                return Err(serde::de::Error::duplicate_field("connections"));
11864                            }
11865                            connections__ = Some(map_.next_value()?);
11866                        }
11867                        GeneratedField::Subscriptions => {
11868                            if subscriptions__.is_some() {
11869                                return Err(serde::de::Error::duplicate_field("subscriptions"));
11870                            }
11871                            subscriptions__ = Some(map_.next_value()?);
11872                        }
11873                        GeneratedField::Users => {
11874                            if users__.is_some() {
11875                                return Err(serde::de::Error::duplicate_field("users"));
11876                            }
11877                            users__ = Some(map_.next_value()?);
11878                        }
11879                        GeneratedField::SessionParams => {
11880                            if session_params__.is_some() {
11881                                return Err(serde::de::Error::duplicate_field("sessionParams"));
11882                            }
11883                            session_params__ = map_.next_value()?;
11884                        }
11885                        GeneratedField::Secrets => {
11886                            if secrets__.is_some() {
11887                                return Err(serde::de::Error::duplicate_field("secrets"));
11888                            }
11889                            secrets__ = Some(map_.next_value()?);
11890                        }
11891                        GeneratedField::ComputeNodeTotalCpuCount => {
11892                            if compute_node_total_cpu_count__.is_some() {
11893                                return Err(serde::de::Error::duplicate_field("computeNodeTotalCpuCount"));
11894                            }
11895                            compute_node_total_cpu_count__ = 
11896                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11897                            ;
11898                        }
11899                        GeneratedField::Nodes => {
11900                            if nodes__.is_some() {
11901                                return Err(serde::de::Error::duplicate_field("nodes"));
11902                            }
11903                            nodes__ = Some(map_.next_value()?);
11904                        }
11905                        GeneratedField::HummockVersion => {
11906                            if hummock_version__.is_some() {
11907                                return Err(serde::de::Error::duplicate_field("hummockVersion"));
11908                            }
11909                            hummock_version__ = map_.next_value()?;
11910                        }
11911                        GeneratedField::MetaBackupManifestId => {
11912                            if meta_backup_manifest_id__.is_some() {
11913                                return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
11914                            }
11915                            meta_backup_manifest_id__ = map_.next_value()?;
11916                        }
11917                        GeneratedField::HummockWriteLimits => {
11918                            if hummock_write_limits__.is_some() {
11919                                return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
11920                            }
11921                            hummock_write_limits__ = map_.next_value()?;
11922                        }
11923                        GeneratedField::StreamingWorkerSlotMappings => {
11924                            if streaming_worker_slot_mappings__.is_some() {
11925                                return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
11926                            }
11927                            streaming_worker_slot_mappings__ = Some(map_.next_value()?);
11928                        }
11929                        GeneratedField::ServingWorkerSlotMappings => {
11930                            if serving_worker_slot_mappings__.is_some() {
11931                                return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
11932                            }
11933                            serving_worker_slot_mappings__ = Some(map_.next_value()?);
11934                        }
11935                        GeneratedField::Version => {
11936                            if version__.is_some() {
11937                                return Err(serde::de::Error::duplicate_field("version"));
11938                            }
11939                            version__ = map_.next_value()?;
11940                        }
11941                    }
11942                }
11943                Ok(MetaSnapshot {
11944                    databases: databases__.unwrap_or_default(),
11945                    schemas: schemas__.unwrap_or_default(),
11946                    sources: sources__.unwrap_or_default(),
11947                    sinks: sinks__.unwrap_or_default(),
11948                    tables: tables__.unwrap_or_default(),
11949                    indexes: indexes__.unwrap_or_default(),
11950                    views: views__.unwrap_or_default(),
11951                    functions: functions__.unwrap_or_default(),
11952                    connections: connections__.unwrap_or_default(),
11953                    subscriptions: subscriptions__.unwrap_or_default(),
11954                    users: users__.unwrap_or_default(),
11955                    session_params: session_params__,
11956                    secrets: secrets__.unwrap_or_default(),
11957                    compute_node_total_cpu_count: compute_node_total_cpu_count__.unwrap_or_default(),
11958                    nodes: nodes__.unwrap_or_default(),
11959                    hummock_version: hummock_version__,
11960                    meta_backup_manifest_id: meta_backup_manifest_id__,
11961                    hummock_write_limits: hummock_write_limits__,
11962                    streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
11963                    serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
11964                    version: version__,
11965                })
11966            }
11967        }
11968        deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
11969    }
11970}
11971impl serde::Serialize for meta_snapshot::SnapshotVersion {
11972    #[allow(deprecated)]
11973    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11974    where
11975        S: serde::Serializer,
11976    {
11977        use serde::ser::SerializeStruct;
11978        let mut len = 0;
11979        if self.catalog_version != 0 {
11980            len += 1;
11981        }
11982        if self.worker_node_version != 0 {
11983            len += 1;
11984        }
11985        if self.streaming_worker_slot_mapping_version != 0 {
11986            len += 1;
11987        }
11988        let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
11989        if self.catalog_version != 0 {
11990            #[allow(clippy::needless_borrow)]
11991            #[allow(clippy::needless_borrows_for_generic_args)]
11992            struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
11993        }
11994        if self.worker_node_version != 0 {
11995            #[allow(clippy::needless_borrow)]
11996            #[allow(clippy::needless_borrows_for_generic_args)]
11997            struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
11998        }
11999        if self.streaming_worker_slot_mapping_version != 0 {
12000            #[allow(clippy::needless_borrow)]
12001            #[allow(clippy::needless_borrows_for_generic_args)]
12002            struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
12003        }
12004        struct_ser.end()
12005    }
12006}
12007impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
12008    #[allow(deprecated)]
12009    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12010    where
12011        D: serde::Deserializer<'de>,
12012    {
12013        const FIELDS: &[&str] = &[
12014            "catalog_version",
12015            "catalogVersion",
12016            "worker_node_version",
12017            "workerNodeVersion",
12018            "streaming_worker_slot_mapping_version",
12019            "streamingWorkerSlotMappingVersion",
12020        ];
12021
12022        #[allow(clippy::enum_variant_names)]
12023        enum GeneratedField {
12024            CatalogVersion,
12025            WorkerNodeVersion,
12026            StreamingWorkerSlotMappingVersion,
12027        }
12028        impl<'de> serde::Deserialize<'de> for GeneratedField {
12029            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12030            where
12031                D: serde::Deserializer<'de>,
12032            {
12033                struct GeneratedVisitor;
12034
12035                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12036                    type Value = GeneratedField;
12037
12038                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12039                        write!(formatter, "expected one of: {:?}", &FIELDS)
12040                    }
12041
12042                    #[allow(unused_variables)]
12043                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12044                    where
12045                        E: serde::de::Error,
12046                    {
12047                        match value {
12048                            "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
12049                            "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
12050                            "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
12051                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12052                        }
12053                    }
12054                }
12055                deserializer.deserialize_identifier(GeneratedVisitor)
12056            }
12057        }
12058        struct GeneratedVisitor;
12059        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12060            type Value = meta_snapshot::SnapshotVersion;
12061
12062            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12063                formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
12064            }
12065
12066            fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
12067                where
12068                    V: serde::de::MapAccess<'de>,
12069            {
12070                let mut catalog_version__ = None;
12071                let mut worker_node_version__ = None;
12072                let mut streaming_worker_slot_mapping_version__ = None;
12073                while let Some(k) = map_.next_key()? {
12074                    match k {
12075                        GeneratedField::CatalogVersion => {
12076                            if catalog_version__.is_some() {
12077                                return Err(serde::de::Error::duplicate_field("catalogVersion"));
12078                            }
12079                            catalog_version__ = 
12080                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12081                            ;
12082                        }
12083                        GeneratedField::WorkerNodeVersion => {
12084                            if worker_node_version__.is_some() {
12085                                return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
12086                            }
12087                            worker_node_version__ = 
12088                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12089                            ;
12090                        }
12091                        GeneratedField::StreamingWorkerSlotMappingVersion => {
12092                            if streaming_worker_slot_mapping_version__.is_some() {
12093                                return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
12094                            }
12095                            streaming_worker_slot_mapping_version__ = 
12096                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12097                            ;
12098                        }
12099                    }
12100                }
12101                Ok(meta_snapshot::SnapshotVersion {
12102                    catalog_version: catalog_version__.unwrap_or_default(),
12103                    worker_node_version: worker_node_version__.unwrap_or_default(),
12104                    streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
12105                })
12106            }
12107        }
12108        deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
12109    }
12110}
12111impl serde::Serialize for MigrationPlan {
12112    #[allow(deprecated)]
12113    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12114    where
12115        S: serde::Serializer,
12116    {
12117        use serde::ser::SerializeStruct;
12118        let mut len = 0;
12119        if !self.worker_slot_migration_plan.is_empty() {
12120            len += 1;
12121        }
12122        let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
12123        if !self.worker_slot_migration_plan.is_empty() {
12124            let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
12125                .map(|(k, v)| (k, v.to_string())).collect();
12126            struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
12127        }
12128        struct_ser.end()
12129    }
12130}
12131impl<'de> serde::Deserialize<'de> for MigrationPlan {
12132    #[allow(deprecated)]
12133    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12134    where
12135        D: serde::Deserializer<'de>,
12136    {
12137        const FIELDS: &[&str] = &[
12138            "worker_slot_migration_plan",
12139            "workerSlotMigrationPlan",
12140        ];
12141
12142        #[allow(clippy::enum_variant_names)]
12143        enum GeneratedField {
12144            WorkerSlotMigrationPlan,
12145        }
12146        impl<'de> serde::Deserialize<'de> for GeneratedField {
12147            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12148            where
12149                D: serde::Deserializer<'de>,
12150            {
12151                struct GeneratedVisitor;
12152
12153                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12154                    type Value = GeneratedField;
12155
12156                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12157                        write!(formatter, "expected one of: {:?}", &FIELDS)
12158                    }
12159
12160                    #[allow(unused_variables)]
12161                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12162                    where
12163                        E: serde::de::Error,
12164                    {
12165                        match value {
12166                            "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
12167                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12168                        }
12169                    }
12170                }
12171                deserializer.deserialize_identifier(GeneratedVisitor)
12172            }
12173        }
12174        struct GeneratedVisitor;
12175        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12176            type Value = MigrationPlan;
12177
12178            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12179                formatter.write_str("struct meta.MigrationPlan")
12180            }
12181
12182            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
12183                where
12184                    V: serde::de::MapAccess<'de>,
12185            {
12186                let mut worker_slot_migration_plan__ = None;
12187                while let Some(k) = map_.next_key()? {
12188                    match k {
12189                        GeneratedField::WorkerSlotMigrationPlan => {
12190                            if worker_slot_migration_plan__.is_some() {
12191                                return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
12192                            }
12193                            worker_slot_migration_plan__ = Some(
12194                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
12195                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
12196                            );
12197                        }
12198                    }
12199                }
12200                Ok(MigrationPlan {
12201                    worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
12202                })
12203            }
12204        }
12205        deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
12206    }
12207}
12208impl serde::Serialize for Object {
12209    #[allow(deprecated)]
12210    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12211    where
12212        S: serde::Serializer,
12213    {
12214        use serde::ser::SerializeStruct;
12215        let mut len = 0;
12216        if self.object_info.is_some() {
12217            len += 1;
12218        }
12219        let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
12220        if let Some(v) = self.object_info.as_ref() {
12221            match v {
12222                object::ObjectInfo::Database(v) => {
12223                    struct_ser.serialize_field("database", v)?;
12224                }
12225                object::ObjectInfo::Schema(v) => {
12226                    struct_ser.serialize_field("schema", v)?;
12227                }
12228                object::ObjectInfo::Table(v) => {
12229                    struct_ser.serialize_field("table", v)?;
12230                }
12231                object::ObjectInfo::Index(v) => {
12232                    struct_ser.serialize_field("index", v)?;
12233                }
12234                object::ObjectInfo::Source(v) => {
12235                    struct_ser.serialize_field("source", v)?;
12236                }
12237                object::ObjectInfo::Sink(v) => {
12238                    struct_ser.serialize_field("sink", v)?;
12239                }
12240                object::ObjectInfo::View(v) => {
12241                    struct_ser.serialize_field("view", v)?;
12242                }
12243                object::ObjectInfo::Function(v) => {
12244                    struct_ser.serialize_field("function", v)?;
12245                }
12246                object::ObjectInfo::Connection(v) => {
12247                    struct_ser.serialize_field("connection", v)?;
12248                }
12249                object::ObjectInfo::Subscription(v) => {
12250                    struct_ser.serialize_field("subscription", v)?;
12251                }
12252                object::ObjectInfo::Secret(v) => {
12253                    struct_ser.serialize_field("secret", v)?;
12254                }
12255            }
12256        }
12257        struct_ser.end()
12258    }
12259}
12260impl<'de> serde::Deserialize<'de> for Object {
12261    #[allow(deprecated)]
12262    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12263    where
12264        D: serde::Deserializer<'de>,
12265    {
12266        const FIELDS: &[&str] = &[
12267            "database",
12268            "schema",
12269            "table",
12270            "index",
12271            "source",
12272            "sink",
12273            "view",
12274            "function",
12275            "connection",
12276            "subscription",
12277            "secret",
12278        ];
12279
12280        #[allow(clippy::enum_variant_names)]
12281        enum GeneratedField {
12282            Database,
12283            Schema,
12284            Table,
12285            Index,
12286            Source,
12287            Sink,
12288            View,
12289            Function,
12290            Connection,
12291            Subscription,
12292            Secret,
12293        }
12294        impl<'de> serde::Deserialize<'de> for GeneratedField {
12295            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12296            where
12297                D: serde::Deserializer<'de>,
12298            {
12299                struct GeneratedVisitor;
12300
12301                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12302                    type Value = GeneratedField;
12303
12304                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12305                        write!(formatter, "expected one of: {:?}", &FIELDS)
12306                    }
12307
12308                    #[allow(unused_variables)]
12309                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12310                    where
12311                        E: serde::de::Error,
12312                    {
12313                        match value {
12314                            "database" => Ok(GeneratedField::Database),
12315                            "schema" => Ok(GeneratedField::Schema),
12316                            "table" => Ok(GeneratedField::Table),
12317                            "index" => Ok(GeneratedField::Index),
12318                            "source" => Ok(GeneratedField::Source),
12319                            "sink" => Ok(GeneratedField::Sink),
12320                            "view" => Ok(GeneratedField::View),
12321                            "function" => Ok(GeneratedField::Function),
12322                            "connection" => Ok(GeneratedField::Connection),
12323                            "subscription" => Ok(GeneratedField::Subscription),
12324                            "secret" => Ok(GeneratedField::Secret),
12325                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12326                        }
12327                    }
12328                }
12329                deserializer.deserialize_identifier(GeneratedVisitor)
12330            }
12331        }
12332        struct GeneratedVisitor;
12333        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12334            type Value = Object;
12335
12336            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12337                formatter.write_str("struct meta.Object")
12338            }
12339
12340            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
12341                where
12342                    V: serde::de::MapAccess<'de>,
12343            {
12344                let mut object_info__ = None;
12345                while let Some(k) = map_.next_key()? {
12346                    match k {
12347                        GeneratedField::Database => {
12348                            if object_info__.is_some() {
12349                                return Err(serde::de::Error::duplicate_field("database"));
12350                            }
12351                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
12352;
12353                        }
12354                        GeneratedField::Schema => {
12355                            if object_info__.is_some() {
12356                                return Err(serde::de::Error::duplicate_field("schema"));
12357                            }
12358                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
12359;
12360                        }
12361                        GeneratedField::Table => {
12362                            if object_info__.is_some() {
12363                                return Err(serde::de::Error::duplicate_field("table"));
12364                            }
12365                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
12366;
12367                        }
12368                        GeneratedField::Index => {
12369                            if object_info__.is_some() {
12370                                return Err(serde::de::Error::duplicate_field("index"));
12371                            }
12372                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
12373;
12374                        }
12375                        GeneratedField::Source => {
12376                            if object_info__.is_some() {
12377                                return Err(serde::de::Error::duplicate_field("source"));
12378                            }
12379                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
12380;
12381                        }
12382                        GeneratedField::Sink => {
12383                            if object_info__.is_some() {
12384                                return Err(serde::de::Error::duplicate_field("sink"));
12385                            }
12386                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
12387;
12388                        }
12389                        GeneratedField::View => {
12390                            if object_info__.is_some() {
12391                                return Err(serde::de::Error::duplicate_field("view"));
12392                            }
12393                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
12394;
12395                        }
12396                        GeneratedField::Function => {
12397                            if object_info__.is_some() {
12398                                return Err(serde::de::Error::duplicate_field("function"));
12399                            }
12400                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
12401;
12402                        }
12403                        GeneratedField::Connection => {
12404                            if object_info__.is_some() {
12405                                return Err(serde::de::Error::duplicate_field("connection"));
12406                            }
12407                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
12408;
12409                        }
12410                        GeneratedField::Subscription => {
12411                            if object_info__.is_some() {
12412                                return Err(serde::de::Error::duplicate_field("subscription"));
12413                            }
12414                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
12415;
12416                        }
12417                        GeneratedField::Secret => {
12418                            if object_info__.is_some() {
12419                                return Err(serde::de::Error::duplicate_field("secret"));
12420                            }
12421                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
12422;
12423                        }
12424                    }
12425                }
12426                Ok(Object {
12427                    object_info: object_info__,
12428                })
12429            }
12430        }
12431        deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
12432    }
12433}
12434impl serde::Serialize for ObjectGroup {
12435    #[allow(deprecated)]
12436    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12437    where
12438        S: serde::Serializer,
12439    {
12440        use serde::ser::SerializeStruct;
12441        let mut len = 0;
12442        if !self.objects.is_empty() {
12443            len += 1;
12444        }
12445        let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
12446        if !self.objects.is_empty() {
12447            struct_ser.serialize_field("objects", &self.objects)?;
12448        }
12449        struct_ser.end()
12450    }
12451}
12452impl<'de> serde::Deserialize<'de> for ObjectGroup {
12453    #[allow(deprecated)]
12454    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12455    where
12456        D: serde::Deserializer<'de>,
12457    {
12458        const FIELDS: &[&str] = &[
12459            "objects",
12460        ];
12461
12462        #[allow(clippy::enum_variant_names)]
12463        enum GeneratedField {
12464            Objects,
12465        }
12466        impl<'de> serde::Deserialize<'de> for GeneratedField {
12467            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12468            where
12469                D: serde::Deserializer<'de>,
12470            {
12471                struct GeneratedVisitor;
12472
12473                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12474                    type Value = GeneratedField;
12475
12476                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12477                        write!(formatter, "expected one of: {:?}", &FIELDS)
12478                    }
12479
12480                    #[allow(unused_variables)]
12481                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12482                    where
12483                        E: serde::de::Error,
12484                    {
12485                        match value {
12486                            "objects" => Ok(GeneratedField::Objects),
12487                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12488                        }
12489                    }
12490                }
12491                deserializer.deserialize_identifier(GeneratedVisitor)
12492            }
12493        }
12494        struct GeneratedVisitor;
12495        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12496            type Value = ObjectGroup;
12497
12498            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12499                formatter.write_str("struct meta.ObjectGroup")
12500            }
12501
12502            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
12503                where
12504                    V: serde::de::MapAccess<'de>,
12505            {
12506                let mut objects__ = None;
12507                while let Some(k) = map_.next_key()? {
12508                    match k {
12509                        GeneratedField::Objects => {
12510                            if objects__.is_some() {
12511                                return Err(serde::de::Error::duplicate_field("objects"));
12512                            }
12513                            objects__ = Some(map_.next_value()?);
12514                        }
12515                    }
12516                }
12517                Ok(ObjectGroup {
12518                    objects: objects__.unwrap_or_default(),
12519                })
12520            }
12521        }
12522        deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
12523    }
12524}
12525impl serde::Serialize for PauseRequest {
12526    #[allow(deprecated)]
12527    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12528    where
12529        S: serde::Serializer,
12530    {
12531        use serde::ser::SerializeStruct;
12532        let len = 0;
12533        let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
12534        struct_ser.end()
12535    }
12536}
12537impl<'de> serde::Deserialize<'de> for PauseRequest {
12538    #[allow(deprecated)]
12539    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12540    where
12541        D: serde::Deserializer<'de>,
12542    {
12543        const FIELDS: &[&str] = &[
12544        ];
12545
12546        #[allow(clippy::enum_variant_names)]
12547        enum GeneratedField {
12548        }
12549        impl<'de> serde::Deserialize<'de> for GeneratedField {
12550            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12551            where
12552                D: serde::Deserializer<'de>,
12553            {
12554                struct GeneratedVisitor;
12555
12556                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12557                    type Value = GeneratedField;
12558
12559                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12560                        write!(formatter, "expected one of: {:?}", &FIELDS)
12561                    }
12562
12563                    #[allow(unused_variables)]
12564                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12565                    where
12566                        E: serde::de::Error,
12567                    {
12568                            Err(serde::de::Error::unknown_field(value, FIELDS))
12569                    }
12570                }
12571                deserializer.deserialize_identifier(GeneratedVisitor)
12572            }
12573        }
12574        struct GeneratedVisitor;
12575        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12576            type Value = PauseRequest;
12577
12578            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12579                formatter.write_str("struct meta.PauseRequest")
12580            }
12581
12582            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
12583                where
12584                    V: serde::de::MapAccess<'de>,
12585            {
12586                while map_.next_key::<GeneratedField>()?.is_some() {
12587                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12588                }
12589                Ok(PauseRequest {
12590                })
12591            }
12592        }
12593        deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
12594    }
12595}
12596impl serde::Serialize for PauseResponse {
12597    #[allow(deprecated)]
12598    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12599    where
12600        S: serde::Serializer,
12601    {
12602        use serde::ser::SerializeStruct;
12603        let len = 0;
12604        let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
12605        struct_ser.end()
12606    }
12607}
12608impl<'de> serde::Deserialize<'de> for PauseResponse {
12609    #[allow(deprecated)]
12610    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12611    where
12612        D: serde::Deserializer<'de>,
12613    {
12614        const FIELDS: &[&str] = &[
12615        ];
12616
12617        #[allow(clippy::enum_variant_names)]
12618        enum GeneratedField {
12619        }
12620        impl<'de> serde::Deserialize<'de> for GeneratedField {
12621            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12622            where
12623                D: serde::Deserializer<'de>,
12624            {
12625                struct GeneratedVisitor;
12626
12627                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12628                    type Value = GeneratedField;
12629
12630                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12631                        write!(formatter, "expected one of: {:?}", &FIELDS)
12632                    }
12633
12634                    #[allow(unused_variables)]
12635                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12636                    where
12637                        E: serde::de::Error,
12638                    {
12639                            Err(serde::de::Error::unknown_field(value, FIELDS))
12640                    }
12641                }
12642                deserializer.deserialize_identifier(GeneratedVisitor)
12643            }
12644        }
12645        struct GeneratedVisitor;
12646        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12647            type Value = PauseResponse;
12648
12649            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12650                formatter.write_str("struct meta.PauseResponse")
12651            }
12652
12653            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
12654                where
12655                    V: serde::de::MapAccess<'de>,
12656            {
12657                while map_.next_key::<GeneratedField>()?.is_some() {
12658                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12659                }
12660                Ok(PauseResponse {
12661                })
12662            }
12663        }
12664        deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
12665    }
12666}
12667impl serde::Serialize for RecoverRequest {
12668    #[allow(deprecated)]
12669    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12670    where
12671        S: serde::Serializer,
12672    {
12673        use serde::ser::SerializeStruct;
12674        let len = 0;
12675        let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
12676        struct_ser.end()
12677    }
12678}
12679impl<'de> serde::Deserialize<'de> for RecoverRequest {
12680    #[allow(deprecated)]
12681    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12682    where
12683        D: serde::Deserializer<'de>,
12684    {
12685        const FIELDS: &[&str] = &[
12686        ];
12687
12688        #[allow(clippy::enum_variant_names)]
12689        enum GeneratedField {
12690        }
12691        impl<'de> serde::Deserialize<'de> for GeneratedField {
12692            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12693            where
12694                D: serde::Deserializer<'de>,
12695            {
12696                struct GeneratedVisitor;
12697
12698                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12699                    type Value = GeneratedField;
12700
12701                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12702                        write!(formatter, "expected one of: {:?}", &FIELDS)
12703                    }
12704
12705                    #[allow(unused_variables)]
12706                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12707                    where
12708                        E: serde::de::Error,
12709                    {
12710                            Err(serde::de::Error::unknown_field(value, FIELDS))
12711                    }
12712                }
12713                deserializer.deserialize_identifier(GeneratedVisitor)
12714            }
12715        }
12716        struct GeneratedVisitor;
12717        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12718            type Value = RecoverRequest;
12719
12720            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12721                formatter.write_str("struct meta.RecoverRequest")
12722            }
12723
12724            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
12725                where
12726                    V: serde::de::MapAccess<'de>,
12727            {
12728                while map_.next_key::<GeneratedField>()?.is_some() {
12729                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12730                }
12731                Ok(RecoverRequest {
12732                })
12733            }
12734        }
12735        deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
12736    }
12737}
12738impl serde::Serialize for RecoverResponse {
12739    #[allow(deprecated)]
12740    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12741    where
12742        S: serde::Serializer,
12743    {
12744        use serde::ser::SerializeStruct;
12745        let len = 0;
12746        let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
12747        struct_ser.end()
12748    }
12749}
12750impl<'de> serde::Deserialize<'de> for RecoverResponse {
12751    #[allow(deprecated)]
12752    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12753    where
12754        D: serde::Deserializer<'de>,
12755    {
12756        const FIELDS: &[&str] = &[
12757        ];
12758
12759        #[allow(clippy::enum_variant_names)]
12760        enum GeneratedField {
12761        }
12762        impl<'de> serde::Deserialize<'de> for GeneratedField {
12763            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12764            where
12765                D: serde::Deserializer<'de>,
12766            {
12767                struct GeneratedVisitor;
12768
12769                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12770                    type Value = GeneratedField;
12771
12772                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12773                        write!(formatter, "expected one of: {:?}", &FIELDS)
12774                    }
12775
12776                    #[allow(unused_variables)]
12777                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12778                    where
12779                        E: serde::de::Error,
12780                    {
12781                            Err(serde::de::Error::unknown_field(value, FIELDS))
12782                    }
12783                }
12784                deserializer.deserialize_identifier(GeneratedVisitor)
12785            }
12786        }
12787        struct GeneratedVisitor;
12788        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12789            type Value = RecoverResponse;
12790
12791            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12792                formatter.write_str("struct meta.RecoverResponse")
12793            }
12794
12795            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
12796                where
12797                    V: serde::de::MapAccess<'de>,
12798            {
12799                while map_.next_key::<GeneratedField>()?.is_some() {
12800                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12801                }
12802                Ok(RecoverResponse {
12803                })
12804            }
12805        }
12806        deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
12807    }
12808}
12809impl serde::Serialize for Recovery {
12810    #[allow(deprecated)]
12811    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12812    where
12813        S: serde::Serializer,
12814    {
12815        use serde::ser::SerializeStruct;
12816        let len = 0;
12817        let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
12818        struct_ser.end()
12819    }
12820}
12821impl<'de> serde::Deserialize<'de> for Recovery {
12822    #[allow(deprecated)]
12823    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12824    where
12825        D: serde::Deserializer<'de>,
12826    {
12827        const FIELDS: &[&str] = &[
12828        ];
12829
12830        #[allow(clippy::enum_variant_names)]
12831        enum GeneratedField {
12832        }
12833        impl<'de> serde::Deserialize<'de> for GeneratedField {
12834            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12835            where
12836                D: serde::Deserializer<'de>,
12837            {
12838                struct GeneratedVisitor;
12839
12840                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12841                    type Value = GeneratedField;
12842
12843                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12844                        write!(formatter, "expected one of: {:?}", &FIELDS)
12845                    }
12846
12847                    #[allow(unused_variables)]
12848                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12849                    where
12850                        E: serde::de::Error,
12851                    {
12852                            Err(serde::de::Error::unknown_field(value, FIELDS))
12853                    }
12854                }
12855                deserializer.deserialize_identifier(GeneratedVisitor)
12856            }
12857        }
12858        struct GeneratedVisitor;
12859        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12860            type Value = Recovery;
12861
12862            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12863                formatter.write_str("struct meta.Recovery")
12864            }
12865
12866            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
12867                where
12868                    V: serde::de::MapAccess<'de>,
12869            {
12870                while map_.next_key::<GeneratedField>()?.is_some() {
12871                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12872                }
12873                Ok(Recovery {
12874                })
12875            }
12876        }
12877        deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
12878    }
12879}
12880impl serde::Serialize for RecoveryStatus {
12881    #[allow(deprecated)]
12882    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12883    where
12884        S: serde::Serializer,
12885    {
12886        let variant = match self {
12887            Self::StatusUnspecified => "STATUS_UNSPECIFIED",
12888            Self::StatusStarting => "STATUS_STARTING",
12889            Self::StatusRecovering => "STATUS_RECOVERING",
12890            Self::StatusRunning => "STATUS_RUNNING",
12891        };
12892        serializer.serialize_str(variant)
12893    }
12894}
12895impl<'de> serde::Deserialize<'de> for RecoveryStatus {
12896    #[allow(deprecated)]
12897    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12898    where
12899        D: serde::Deserializer<'de>,
12900    {
12901        const FIELDS: &[&str] = &[
12902            "STATUS_UNSPECIFIED",
12903            "STATUS_STARTING",
12904            "STATUS_RECOVERING",
12905            "STATUS_RUNNING",
12906        ];
12907
12908        struct GeneratedVisitor;
12909
12910        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12911            type Value = RecoveryStatus;
12912
12913            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12914                write!(formatter, "expected one of: {:?}", &FIELDS)
12915            }
12916
12917            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
12918            where
12919                E: serde::de::Error,
12920            {
12921                i32::try_from(v)
12922                    .ok()
12923                    .and_then(|x| x.try_into().ok())
12924                    .ok_or_else(|| {
12925                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12926                    })
12927            }
12928
12929            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12930            where
12931                E: serde::de::Error,
12932            {
12933                i32::try_from(v)
12934                    .ok()
12935                    .and_then(|x| x.try_into().ok())
12936                    .ok_or_else(|| {
12937                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12938                    })
12939            }
12940
12941            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12942            where
12943                E: serde::de::Error,
12944            {
12945                match value {
12946                    "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
12947                    "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
12948                    "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
12949                    "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
12950                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12951                }
12952            }
12953        }
12954        deserializer.deserialize_any(GeneratedVisitor)
12955    }
12956}
12957impl serde::Serialize for RefreshRequest {
12958    #[allow(deprecated)]
12959    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12960    where
12961        S: serde::Serializer,
12962    {
12963        use serde::ser::SerializeStruct;
12964        let mut len = 0;
12965        if self.table_id != 0 {
12966            len += 1;
12967        }
12968        if self.associated_source_id != 0 {
12969            len += 1;
12970        }
12971        let mut struct_ser = serializer.serialize_struct("meta.RefreshRequest", len)?;
12972        if self.table_id != 0 {
12973            struct_ser.serialize_field("tableId", &self.table_id)?;
12974        }
12975        if self.associated_source_id != 0 {
12976            struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
12977        }
12978        struct_ser.end()
12979    }
12980}
12981impl<'de> serde::Deserialize<'de> for RefreshRequest {
12982    #[allow(deprecated)]
12983    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12984    where
12985        D: serde::Deserializer<'de>,
12986    {
12987        const FIELDS: &[&str] = &[
12988            "table_id",
12989            "tableId",
12990            "associated_source_id",
12991            "associatedSourceId",
12992        ];
12993
12994        #[allow(clippy::enum_variant_names)]
12995        enum GeneratedField {
12996            TableId,
12997            AssociatedSourceId,
12998        }
12999        impl<'de> serde::Deserialize<'de> for GeneratedField {
13000            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13001            where
13002                D: serde::Deserializer<'de>,
13003            {
13004                struct GeneratedVisitor;
13005
13006                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13007                    type Value = GeneratedField;
13008
13009                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13010                        write!(formatter, "expected one of: {:?}", &FIELDS)
13011                    }
13012
13013                    #[allow(unused_variables)]
13014                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13015                    where
13016                        E: serde::de::Error,
13017                    {
13018                        match value {
13019                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
13020                            "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
13021                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13022                        }
13023                    }
13024                }
13025                deserializer.deserialize_identifier(GeneratedVisitor)
13026            }
13027        }
13028        struct GeneratedVisitor;
13029        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13030            type Value = RefreshRequest;
13031
13032            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13033                formatter.write_str("struct meta.RefreshRequest")
13034            }
13035
13036            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshRequest, V::Error>
13037                where
13038                    V: serde::de::MapAccess<'de>,
13039            {
13040                let mut table_id__ = None;
13041                let mut associated_source_id__ = None;
13042                while let Some(k) = map_.next_key()? {
13043                    match k {
13044                        GeneratedField::TableId => {
13045                            if table_id__.is_some() {
13046                                return Err(serde::de::Error::duplicate_field("tableId"));
13047                            }
13048                            table_id__ = 
13049                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13050                            ;
13051                        }
13052                        GeneratedField::AssociatedSourceId => {
13053                            if associated_source_id__.is_some() {
13054                                return Err(serde::de::Error::duplicate_field("associatedSourceId"));
13055                            }
13056                            associated_source_id__ = 
13057                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13058                            ;
13059                        }
13060                    }
13061                }
13062                Ok(RefreshRequest {
13063                    table_id: table_id__.unwrap_or_default(),
13064                    associated_source_id: associated_source_id__.unwrap_or_default(),
13065                })
13066            }
13067        }
13068        deserializer.deserialize_struct("meta.RefreshRequest", FIELDS, GeneratedVisitor)
13069    }
13070}
13071impl serde::Serialize for RefreshResponse {
13072    #[allow(deprecated)]
13073    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13074    where
13075        S: serde::Serializer,
13076    {
13077        use serde::ser::SerializeStruct;
13078        let mut len = 0;
13079        if self.status.is_some() {
13080            len += 1;
13081        }
13082        let mut struct_ser = serializer.serialize_struct("meta.RefreshResponse", len)?;
13083        if let Some(v) = self.status.as_ref() {
13084            struct_ser.serialize_field("status", v)?;
13085        }
13086        struct_ser.end()
13087    }
13088}
13089impl<'de> serde::Deserialize<'de> for RefreshResponse {
13090    #[allow(deprecated)]
13091    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13092    where
13093        D: serde::Deserializer<'de>,
13094    {
13095        const FIELDS: &[&str] = &[
13096            "status",
13097        ];
13098
13099        #[allow(clippy::enum_variant_names)]
13100        enum GeneratedField {
13101            Status,
13102        }
13103        impl<'de> serde::Deserialize<'de> for GeneratedField {
13104            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13105            where
13106                D: serde::Deserializer<'de>,
13107            {
13108                struct GeneratedVisitor;
13109
13110                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13111                    type Value = GeneratedField;
13112
13113                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13114                        write!(formatter, "expected one of: {:?}", &FIELDS)
13115                    }
13116
13117                    #[allow(unused_variables)]
13118                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13119                    where
13120                        E: serde::de::Error,
13121                    {
13122                        match value {
13123                            "status" => Ok(GeneratedField::Status),
13124                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13125                        }
13126                    }
13127                }
13128                deserializer.deserialize_identifier(GeneratedVisitor)
13129            }
13130        }
13131        struct GeneratedVisitor;
13132        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13133            type Value = RefreshResponse;
13134
13135            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13136                formatter.write_str("struct meta.RefreshResponse")
13137            }
13138
13139            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshResponse, V::Error>
13140                where
13141                    V: serde::de::MapAccess<'de>,
13142            {
13143                let mut status__ = None;
13144                while let Some(k) = map_.next_key()? {
13145                    match k {
13146                        GeneratedField::Status => {
13147                            if status__.is_some() {
13148                                return Err(serde::de::Error::duplicate_field("status"));
13149                            }
13150                            status__ = map_.next_value()?;
13151                        }
13152                    }
13153                }
13154                Ok(RefreshResponse {
13155                    status: status__,
13156                })
13157            }
13158        }
13159        deserializer.deserialize_struct("meta.RefreshResponse", FIELDS, GeneratedVisitor)
13160    }
13161}
13162impl serde::Serialize for RelationIdInfos {
13163    #[allow(deprecated)]
13164    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13165    where
13166        S: serde::Serializer,
13167    {
13168        use serde::ser::SerializeStruct;
13169        let mut len = 0;
13170        if !self.map.is_empty() {
13171            len += 1;
13172        }
13173        let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
13174        if !self.map.is_empty() {
13175            struct_ser.serialize_field("map", &self.map)?;
13176        }
13177        struct_ser.end()
13178    }
13179}
13180impl<'de> serde::Deserialize<'de> for RelationIdInfos {
13181    #[allow(deprecated)]
13182    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13183    where
13184        D: serde::Deserializer<'de>,
13185    {
13186        const FIELDS: &[&str] = &[
13187            "map",
13188        ];
13189
13190        #[allow(clippy::enum_variant_names)]
13191        enum GeneratedField {
13192            Map,
13193        }
13194        impl<'de> serde::Deserialize<'de> for GeneratedField {
13195            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13196            where
13197                D: serde::Deserializer<'de>,
13198            {
13199                struct GeneratedVisitor;
13200
13201                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13202                    type Value = GeneratedField;
13203
13204                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13205                        write!(formatter, "expected one of: {:?}", &FIELDS)
13206                    }
13207
13208                    #[allow(unused_variables)]
13209                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13210                    where
13211                        E: serde::de::Error,
13212                    {
13213                        match value {
13214                            "map" => Ok(GeneratedField::Map),
13215                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13216                        }
13217                    }
13218                }
13219                deserializer.deserialize_identifier(GeneratedVisitor)
13220            }
13221        }
13222        struct GeneratedVisitor;
13223        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13224            type Value = RelationIdInfos;
13225
13226            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13227                formatter.write_str("struct meta.RelationIdInfos")
13228            }
13229
13230            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
13231                where
13232                    V: serde::de::MapAccess<'de>,
13233            {
13234                let mut map__ = None;
13235                while let Some(k) = map_.next_key()? {
13236                    match k {
13237                        GeneratedField::Map => {
13238                            if map__.is_some() {
13239                                return Err(serde::de::Error::duplicate_field("map"));
13240                            }
13241                            map__ = Some(
13242                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13243                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
13244                            );
13245                        }
13246                    }
13247                }
13248                Ok(RelationIdInfos {
13249                    map: map__.unwrap_or_default(),
13250                })
13251            }
13252        }
13253        deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
13254    }
13255}
13256impl serde::Serialize for RescheduleRequest {
13257    #[allow(deprecated)]
13258    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13259    where
13260        S: serde::Serializer,
13261    {
13262        use serde::ser::SerializeStruct;
13263        let mut len = 0;
13264        if self.revision != 0 {
13265            len += 1;
13266        }
13267        if self.resolve_no_shuffle_upstream {
13268            len += 1;
13269        }
13270        if !self.worker_reschedules.is_empty() {
13271            len += 1;
13272        }
13273        let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
13274        if self.revision != 0 {
13275            #[allow(clippy::needless_borrow)]
13276            #[allow(clippy::needless_borrows_for_generic_args)]
13277            struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
13278        }
13279        if self.resolve_no_shuffle_upstream {
13280            struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
13281        }
13282        if !self.worker_reschedules.is_empty() {
13283            struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
13284        }
13285        struct_ser.end()
13286    }
13287}
13288impl<'de> serde::Deserialize<'de> for RescheduleRequest {
13289    #[allow(deprecated)]
13290    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13291    where
13292        D: serde::Deserializer<'de>,
13293    {
13294        const FIELDS: &[&str] = &[
13295            "revision",
13296            "resolve_no_shuffle_upstream",
13297            "resolveNoShuffleUpstream",
13298            "worker_reschedules",
13299            "workerReschedules",
13300        ];
13301
13302        #[allow(clippy::enum_variant_names)]
13303        enum GeneratedField {
13304            Revision,
13305            ResolveNoShuffleUpstream,
13306            WorkerReschedules,
13307        }
13308        impl<'de> serde::Deserialize<'de> for GeneratedField {
13309            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13310            where
13311                D: serde::Deserializer<'de>,
13312            {
13313                struct GeneratedVisitor;
13314
13315                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13316                    type Value = GeneratedField;
13317
13318                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13319                        write!(formatter, "expected one of: {:?}", &FIELDS)
13320                    }
13321
13322                    #[allow(unused_variables)]
13323                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13324                    where
13325                        E: serde::de::Error,
13326                    {
13327                        match value {
13328                            "revision" => Ok(GeneratedField::Revision),
13329                            "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
13330                            "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
13331                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13332                        }
13333                    }
13334                }
13335                deserializer.deserialize_identifier(GeneratedVisitor)
13336            }
13337        }
13338        struct GeneratedVisitor;
13339        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13340            type Value = RescheduleRequest;
13341
13342            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13343                formatter.write_str("struct meta.RescheduleRequest")
13344            }
13345
13346            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
13347                where
13348                    V: serde::de::MapAccess<'de>,
13349            {
13350                let mut revision__ = None;
13351                let mut resolve_no_shuffle_upstream__ = None;
13352                let mut worker_reschedules__ = None;
13353                while let Some(k) = map_.next_key()? {
13354                    match k {
13355                        GeneratedField::Revision => {
13356                            if revision__.is_some() {
13357                                return Err(serde::de::Error::duplicate_field("revision"));
13358                            }
13359                            revision__ = 
13360                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13361                            ;
13362                        }
13363                        GeneratedField::ResolveNoShuffleUpstream => {
13364                            if resolve_no_shuffle_upstream__.is_some() {
13365                                return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
13366                            }
13367                            resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
13368                        }
13369                        GeneratedField::WorkerReschedules => {
13370                            if worker_reschedules__.is_some() {
13371                                return Err(serde::de::Error::duplicate_field("workerReschedules"));
13372                            }
13373                            worker_reschedules__ = Some(
13374                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13375                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
13376                            );
13377                        }
13378                    }
13379                }
13380                Ok(RescheduleRequest {
13381                    revision: revision__.unwrap_or_default(),
13382                    resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
13383                    worker_reschedules: worker_reschedules__.unwrap_or_default(),
13384                })
13385            }
13386        }
13387        deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
13388    }
13389}
13390impl serde::Serialize for RescheduleResponse {
13391    #[allow(deprecated)]
13392    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13393    where
13394        S: serde::Serializer,
13395    {
13396        use serde::ser::SerializeStruct;
13397        let mut len = 0;
13398        if self.success {
13399            len += 1;
13400        }
13401        if self.revision != 0 {
13402            len += 1;
13403        }
13404        let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
13405        if self.success {
13406            struct_ser.serialize_field("success", &self.success)?;
13407        }
13408        if self.revision != 0 {
13409            #[allow(clippy::needless_borrow)]
13410            #[allow(clippy::needless_borrows_for_generic_args)]
13411            struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
13412        }
13413        struct_ser.end()
13414    }
13415}
13416impl<'de> serde::Deserialize<'de> for RescheduleResponse {
13417    #[allow(deprecated)]
13418    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13419    where
13420        D: serde::Deserializer<'de>,
13421    {
13422        const FIELDS: &[&str] = &[
13423            "success",
13424            "revision",
13425        ];
13426
13427        #[allow(clippy::enum_variant_names)]
13428        enum GeneratedField {
13429            Success,
13430            Revision,
13431        }
13432        impl<'de> serde::Deserialize<'de> for GeneratedField {
13433            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13434            where
13435                D: serde::Deserializer<'de>,
13436            {
13437                struct GeneratedVisitor;
13438
13439                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13440                    type Value = GeneratedField;
13441
13442                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13443                        write!(formatter, "expected one of: {:?}", &FIELDS)
13444                    }
13445
13446                    #[allow(unused_variables)]
13447                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13448                    where
13449                        E: serde::de::Error,
13450                    {
13451                        match value {
13452                            "success" => Ok(GeneratedField::Success),
13453                            "revision" => Ok(GeneratedField::Revision),
13454                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13455                        }
13456                    }
13457                }
13458                deserializer.deserialize_identifier(GeneratedVisitor)
13459            }
13460        }
13461        struct GeneratedVisitor;
13462        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13463            type Value = RescheduleResponse;
13464
13465            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13466                formatter.write_str("struct meta.RescheduleResponse")
13467            }
13468
13469            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
13470                where
13471                    V: serde::de::MapAccess<'de>,
13472            {
13473                let mut success__ = None;
13474                let mut revision__ = None;
13475                while let Some(k) = map_.next_key()? {
13476                    match k {
13477                        GeneratedField::Success => {
13478                            if success__.is_some() {
13479                                return Err(serde::de::Error::duplicate_field("success"));
13480                            }
13481                            success__ = Some(map_.next_value()?);
13482                        }
13483                        GeneratedField::Revision => {
13484                            if revision__.is_some() {
13485                                return Err(serde::de::Error::duplicate_field("revision"));
13486                            }
13487                            revision__ = 
13488                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13489                            ;
13490                        }
13491                    }
13492                }
13493                Ok(RescheduleResponse {
13494                    success: success__.unwrap_or_default(),
13495                    revision: revision__.unwrap_or_default(),
13496                })
13497            }
13498        }
13499        deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
13500    }
13501}
13502impl serde::Serialize for ResumeRequest {
13503    #[allow(deprecated)]
13504    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13505    where
13506        S: serde::Serializer,
13507    {
13508        use serde::ser::SerializeStruct;
13509        let len = 0;
13510        let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
13511        struct_ser.end()
13512    }
13513}
13514impl<'de> serde::Deserialize<'de> for ResumeRequest {
13515    #[allow(deprecated)]
13516    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13517    where
13518        D: serde::Deserializer<'de>,
13519    {
13520        const FIELDS: &[&str] = &[
13521        ];
13522
13523        #[allow(clippy::enum_variant_names)]
13524        enum GeneratedField {
13525        }
13526        impl<'de> serde::Deserialize<'de> for GeneratedField {
13527            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13528            where
13529                D: serde::Deserializer<'de>,
13530            {
13531                struct GeneratedVisitor;
13532
13533                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13534                    type Value = GeneratedField;
13535
13536                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13537                        write!(formatter, "expected one of: {:?}", &FIELDS)
13538                    }
13539
13540                    #[allow(unused_variables)]
13541                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13542                    where
13543                        E: serde::de::Error,
13544                    {
13545                            Err(serde::de::Error::unknown_field(value, FIELDS))
13546                    }
13547                }
13548                deserializer.deserialize_identifier(GeneratedVisitor)
13549            }
13550        }
13551        struct GeneratedVisitor;
13552        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13553            type Value = ResumeRequest;
13554
13555            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13556                formatter.write_str("struct meta.ResumeRequest")
13557            }
13558
13559            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
13560                where
13561                    V: serde::de::MapAccess<'de>,
13562            {
13563                while map_.next_key::<GeneratedField>()?.is_some() {
13564                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13565                }
13566                Ok(ResumeRequest {
13567                })
13568            }
13569        }
13570        deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
13571    }
13572}
13573impl serde::Serialize for ResumeResponse {
13574    #[allow(deprecated)]
13575    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13576    where
13577        S: serde::Serializer,
13578    {
13579        use serde::ser::SerializeStruct;
13580        let len = 0;
13581        let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
13582        struct_ser.end()
13583    }
13584}
13585impl<'de> serde::Deserialize<'de> for ResumeResponse {
13586    #[allow(deprecated)]
13587    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13588    where
13589        D: serde::Deserializer<'de>,
13590    {
13591        const FIELDS: &[&str] = &[
13592        ];
13593
13594        #[allow(clippy::enum_variant_names)]
13595        enum GeneratedField {
13596        }
13597        impl<'de> serde::Deserialize<'de> for GeneratedField {
13598            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13599            where
13600                D: serde::Deserializer<'de>,
13601            {
13602                struct GeneratedVisitor;
13603
13604                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13605                    type Value = GeneratedField;
13606
13607                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13608                        write!(formatter, "expected one of: {:?}", &FIELDS)
13609                    }
13610
13611                    #[allow(unused_variables)]
13612                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13613                    where
13614                        E: serde::de::Error,
13615                    {
13616                            Err(serde::de::Error::unknown_field(value, FIELDS))
13617                    }
13618                }
13619                deserializer.deserialize_identifier(GeneratedVisitor)
13620            }
13621        }
13622        struct GeneratedVisitor;
13623        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13624            type Value = ResumeResponse;
13625
13626            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13627                formatter.write_str("struct meta.ResumeResponse")
13628            }
13629
13630            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
13631                where
13632                    V: serde::de::MapAccess<'de>,
13633            {
13634                while map_.next_key::<GeneratedField>()?.is_some() {
13635                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13636                }
13637                Ok(ResumeResponse {
13638                })
13639            }
13640        }
13641        deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
13642    }
13643}
13644impl serde::Serialize for SetSessionParamRequest {
13645    #[allow(deprecated)]
13646    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13647    where
13648        S: serde::Serializer,
13649    {
13650        use serde::ser::SerializeStruct;
13651        let mut len = 0;
13652        if !self.param.is_empty() {
13653            len += 1;
13654        }
13655        if self.value.is_some() {
13656            len += 1;
13657        }
13658        let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
13659        if !self.param.is_empty() {
13660            struct_ser.serialize_field("param", &self.param)?;
13661        }
13662        if let Some(v) = self.value.as_ref() {
13663            struct_ser.serialize_field("value", v)?;
13664        }
13665        struct_ser.end()
13666    }
13667}
13668impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
13669    #[allow(deprecated)]
13670    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13671    where
13672        D: serde::Deserializer<'de>,
13673    {
13674        const FIELDS: &[&str] = &[
13675            "param",
13676            "value",
13677        ];
13678
13679        #[allow(clippy::enum_variant_names)]
13680        enum GeneratedField {
13681            Param,
13682            Value,
13683        }
13684        impl<'de> serde::Deserialize<'de> for GeneratedField {
13685            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13686            where
13687                D: serde::Deserializer<'de>,
13688            {
13689                struct GeneratedVisitor;
13690
13691                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13692                    type Value = GeneratedField;
13693
13694                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13695                        write!(formatter, "expected one of: {:?}", &FIELDS)
13696                    }
13697
13698                    #[allow(unused_variables)]
13699                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13700                    where
13701                        E: serde::de::Error,
13702                    {
13703                        match value {
13704                            "param" => Ok(GeneratedField::Param),
13705                            "value" => Ok(GeneratedField::Value),
13706                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13707                        }
13708                    }
13709                }
13710                deserializer.deserialize_identifier(GeneratedVisitor)
13711            }
13712        }
13713        struct GeneratedVisitor;
13714        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13715            type Value = SetSessionParamRequest;
13716
13717            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13718                formatter.write_str("struct meta.SetSessionParamRequest")
13719            }
13720
13721            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
13722                where
13723                    V: serde::de::MapAccess<'de>,
13724            {
13725                let mut param__ = None;
13726                let mut value__ = None;
13727                while let Some(k) = map_.next_key()? {
13728                    match k {
13729                        GeneratedField::Param => {
13730                            if param__.is_some() {
13731                                return Err(serde::de::Error::duplicate_field("param"));
13732                            }
13733                            param__ = Some(map_.next_value()?);
13734                        }
13735                        GeneratedField::Value => {
13736                            if value__.is_some() {
13737                                return Err(serde::de::Error::duplicate_field("value"));
13738                            }
13739                            value__ = map_.next_value()?;
13740                        }
13741                    }
13742                }
13743                Ok(SetSessionParamRequest {
13744                    param: param__.unwrap_or_default(),
13745                    value: value__,
13746                })
13747            }
13748        }
13749        deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
13750    }
13751}
13752impl serde::Serialize for SetSessionParamResponse {
13753    #[allow(deprecated)]
13754    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13755    where
13756        S: serde::Serializer,
13757    {
13758        use serde::ser::SerializeStruct;
13759        let mut len = 0;
13760        if !self.param.is_empty() {
13761            len += 1;
13762        }
13763        let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
13764        if !self.param.is_empty() {
13765            struct_ser.serialize_field("param", &self.param)?;
13766        }
13767        struct_ser.end()
13768    }
13769}
13770impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
13771    #[allow(deprecated)]
13772    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13773    where
13774        D: serde::Deserializer<'de>,
13775    {
13776        const FIELDS: &[&str] = &[
13777            "param",
13778        ];
13779
13780        #[allow(clippy::enum_variant_names)]
13781        enum GeneratedField {
13782            Param,
13783        }
13784        impl<'de> serde::Deserialize<'de> for GeneratedField {
13785            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13786            where
13787                D: serde::Deserializer<'de>,
13788            {
13789                struct GeneratedVisitor;
13790
13791                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13792                    type Value = GeneratedField;
13793
13794                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13795                        write!(formatter, "expected one of: {:?}", &FIELDS)
13796                    }
13797
13798                    #[allow(unused_variables)]
13799                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13800                    where
13801                        E: serde::de::Error,
13802                    {
13803                        match value {
13804                            "param" => Ok(GeneratedField::Param),
13805                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13806                        }
13807                    }
13808                }
13809                deserializer.deserialize_identifier(GeneratedVisitor)
13810            }
13811        }
13812        struct GeneratedVisitor;
13813        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13814            type Value = SetSessionParamResponse;
13815
13816            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13817                formatter.write_str("struct meta.SetSessionParamResponse")
13818            }
13819
13820            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
13821                where
13822                    V: serde::de::MapAccess<'de>,
13823            {
13824                let mut param__ = None;
13825                while let Some(k) = map_.next_key()? {
13826                    match k {
13827                        GeneratedField::Param => {
13828                            if param__.is_some() {
13829                                return Err(serde::de::Error::duplicate_field("param"));
13830                            }
13831                            param__ = Some(map_.next_value()?);
13832                        }
13833                    }
13834                }
13835                Ok(SetSessionParamResponse {
13836                    param: param__.unwrap_or_default(),
13837                })
13838            }
13839        }
13840        deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
13841    }
13842}
13843impl serde::Serialize for SetSyncLogStoreAlignedRequest {
13844    #[allow(deprecated)]
13845    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13846    where
13847        S: serde::Serializer,
13848    {
13849        use serde::ser::SerializeStruct;
13850        let mut len = 0;
13851        if self.job_id != 0 {
13852            len += 1;
13853        }
13854        if self.aligned {
13855            len += 1;
13856        }
13857        let mut struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedRequest", len)?;
13858        if self.job_id != 0 {
13859            struct_ser.serialize_field("jobId", &self.job_id)?;
13860        }
13861        if self.aligned {
13862            struct_ser.serialize_field("aligned", &self.aligned)?;
13863        }
13864        struct_ser.end()
13865    }
13866}
13867impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedRequest {
13868    #[allow(deprecated)]
13869    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13870    where
13871        D: serde::Deserializer<'de>,
13872    {
13873        const FIELDS: &[&str] = &[
13874            "job_id",
13875            "jobId",
13876            "aligned",
13877        ];
13878
13879        #[allow(clippy::enum_variant_names)]
13880        enum GeneratedField {
13881            JobId,
13882            Aligned,
13883        }
13884        impl<'de> serde::Deserialize<'de> for GeneratedField {
13885            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13886            where
13887                D: serde::Deserializer<'de>,
13888            {
13889                struct GeneratedVisitor;
13890
13891                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13892                    type Value = GeneratedField;
13893
13894                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13895                        write!(formatter, "expected one of: {:?}", &FIELDS)
13896                    }
13897
13898                    #[allow(unused_variables)]
13899                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13900                    where
13901                        E: serde::de::Error,
13902                    {
13903                        match value {
13904                            "jobId" | "job_id" => Ok(GeneratedField::JobId),
13905                            "aligned" => Ok(GeneratedField::Aligned),
13906                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13907                        }
13908                    }
13909                }
13910                deserializer.deserialize_identifier(GeneratedVisitor)
13911            }
13912        }
13913        struct GeneratedVisitor;
13914        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13915            type Value = SetSyncLogStoreAlignedRequest;
13916
13917            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13918                formatter.write_str("struct meta.SetSyncLogStoreAlignedRequest")
13919            }
13920
13921            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedRequest, V::Error>
13922                where
13923                    V: serde::de::MapAccess<'de>,
13924            {
13925                let mut job_id__ = None;
13926                let mut aligned__ = None;
13927                while let Some(k) = map_.next_key()? {
13928                    match k {
13929                        GeneratedField::JobId => {
13930                            if job_id__.is_some() {
13931                                return Err(serde::de::Error::duplicate_field("jobId"));
13932                            }
13933                            job_id__ = 
13934                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13935                            ;
13936                        }
13937                        GeneratedField::Aligned => {
13938                            if aligned__.is_some() {
13939                                return Err(serde::de::Error::duplicate_field("aligned"));
13940                            }
13941                            aligned__ = Some(map_.next_value()?);
13942                        }
13943                    }
13944                }
13945                Ok(SetSyncLogStoreAlignedRequest {
13946                    job_id: job_id__.unwrap_or_default(),
13947                    aligned: aligned__.unwrap_or_default(),
13948                })
13949            }
13950        }
13951        deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedRequest", FIELDS, GeneratedVisitor)
13952    }
13953}
13954impl serde::Serialize for SetSyncLogStoreAlignedResponse {
13955    #[allow(deprecated)]
13956    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13957    where
13958        S: serde::Serializer,
13959    {
13960        use serde::ser::SerializeStruct;
13961        let len = 0;
13962        let struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedResponse", len)?;
13963        struct_ser.end()
13964    }
13965}
13966impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedResponse {
13967    #[allow(deprecated)]
13968    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13969    where
13970        D: serde::Deserializer<'de>,
13971    {
13972        const FIELDS: &[&str] = &[
13973        ];
13974
13975        #[allow(clippy::enum_variant_names)]
13976        enum GeneratedField {
13977        }
13978        impl<'de> serde::Deserialize<'de> for GeneratedField {
13979            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13980            where
13981                D: serde::Deserializer<'de>,
13982            {
13983                struct GeneratedVisitor;
13984
13985                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13986                    type Value = GeneratedField;
13987
13988                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13989                        write!(formatter, "expected one of: {:?}", &FIELDS)
13990                    }
13991
13992                    #[allow(unused_variables)]
13993                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13994                    where
13995                        E: serde::de::Error,
13996                    {
13997                            Err(serde::de::Error::unknown_field(value, FIELDS))
13998                    }
13999                }
14000                deserializer.deserialize_identifier(GeneratedVisitor)
14001            }
14002        }
14003        struct GeneratedVisitor;
14004        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14005            type Value = SetSyncLogStoreAlignedResponse;
14006
14007            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14008                formatter.write_str("struct meta.SetSyncLogStoreAlignedResponse")
14009            }
14010
14011            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedResponse, V::Error>
14012                where
14013                    V: serde::de::MapAccess<'de>,
14014            {
14015                while map_.next_key::<GeneratedField>()?.is_some() {
14016                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14017                }
14018                Ok(SetSyncLogStoreAlignedResponse {
14019                })
14020            }
14021        }
14022        deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedResponse", FIELDS, GeneratedVisitor)
14023    }
14024}
14025impl serde::Serialize for SetSystemParamRequest {
14026    #[allow(deprecated)]
14027    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14028    where
14029        S: serde::Serializer,
14030    {
14031        use serde::ser::SerializeStruct;
14032        let mut len = 0;
14033        if !self.param.is_empty() {
14034            len += 1;
14035        }
14036        if self.value.is_some() {
14037            len += 1;
14038        }
14039        let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
14040        if !self.param.is_empty() {
14041            struct_ser.serialize_field("param", &self.param)?;
14042        }
14043        if let Some(v) = self.value.as_ref() {
14044            struct_ser.serialize_field("value", v)?;
14045        }
14046        struct_ser.end()
14047    }
14048}
14049impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
14050    #[allow(deprecated)]
14051    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14052    where
14053        D: serde::Deserializer<'de>,
14054    {
14055        const FIELDS: &[&str] = &[
14056            "param",
14057            "value",
14058        ];
14059
14060        #[allow(clippy::enum_variant_names)]
14061        enum GeneratedField {
14062            Param,
14063            Value,
14064        }
14065        impl<'de> serde::Deserialize<'de> for GeneratedField {
14066            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14067            where
14068                D: serde::Deserializer<'de>,
14069            {
14070                struct GeneratedVisitor;
14071
14072                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14073                    type Value = GeneratedField;
14074
14075                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14076                        write!(formatter, "expected one of: {:?}", &FIELDS)
14077                    }
14078
14079                    #[allow(unused_variables)]
14080                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14081                    where
14082                        E: serde::de::Error,
14083                    {
14084                        match value {
14085                            "param" => Ok(GeneratedField::Param),
14086                            "value" => Ok(GeneratedField::Value),
14087                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14088                        }
14089                    }
14090                }
14091                deserializer.deserialize_identifier(GeneratedVisitor)
14092            }
14093        }
14094        struct GeneratedVisitor;
14095        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14096            type Value = SetSystemParamRequest;
14097
14098            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14099                formatter.write_str("struct meta.SetSystemParamRequest")
14100            }
14101
14102            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
14103                where
14104                    V: serde::de::MapAccess<'de>,
14105            {
14106                let mut param__ = None;
14107                let mut value__ = None;
14108                while let Some(k) = map_.next_key()? {
14109                    match k {
14110                        GeneratedField::Param => {
14111                            if param__.is_some() {
14112                                return Err(serde::de::Error::duplicate_field("param"));
14113                            }
14114                            param__ = Some(map_.next_value()?);
14115                        }
14116                        GeneratedField::Value => {
14117                            if value__.is_some() {
14118                                return Err(serde::de::Error::duplicate_field("value"));
14119                            }
14120                            value__ = map_.next_value()?;
14121                        }
14122                    }
14123                }
14124                Ok(SetSystemParamRequest {
14125                    param: param__.unwrap_or_default(),
14126                    value: value__,
14127                })
14128            }
14129        }
14130        deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
14131    }
14132}
14133impl serde::Serialize for SetSystemParamResponse {
14134    #[allow(deprecated)]
14135    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14136    where
14137        S: serde::Serializer,
14138    {
14139        use serde::ser::SerializeStruct;
14140        let mut len = 0;
14141        if self.params.is_some() {
14142            len += 1;
14143        }
14144        let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
14145        if let Some(v) = self.params.as_ref() {
14146            struct_ser.serialize_field("params", v)?;
14147        }
14148        struct_ser.end()
14149    }
14150}
14151impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
14152    #[allow(deprecated)]
14153    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14154    where
14155        D: serde::Deserializer<'de>,
14156    {
14157        const FIELDS: &[&str] = &[
14158            "params",
14159        ];
14160
14161        #[allow(clippy::enum_variant_names)]
14162        enum GeneratedField {
14163            Params,
14164        }
14165        impl<'de> serde::Deserialize<'de> for GeneratedField {
14166            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14167            where
14168                D: serde::Deserializer<'de>,
14169            {
14170                struct GeneratedVisitor;
14171
14172                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14173                    type Value = GeneratedField;
14174
14175                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14176                        write!(formatter, "expected one of: {:?}", &FIELDS)
14177                    }
14178
14179                    #[allow(unused_variables)]
14180                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14181                    where
14182                        E: serde::de::Error,
14183                    {
14184                        match value {
14185                            "params" => Ok(GeneratedField::Params),
14186                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14187                        }
14188                    }
14189                }
14190                deserializer.deserialize_identifier(GeneratedVisitor)
14191            }
14192        }
14193        struct GeneratedVisitor;
14194        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14195            type Value = SetSystemParamResponse;
14196
14197            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14198                formatter.write_str("struct meta.SetSystemParamResponse")
14199            }
14200
14201            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
14202                where
14203                    V: serde::de::MapAccess<'de>,
14204            {
14205                let mut params__ = None;
14206                while let Some(k) = map_.next_key()? {
14207                    match k {
14208                        GeneratedField::Params => {
14209                            if params__.is_some() {
14210                                return Err(serde::de::Error::duplicate_field("params"));
14211                            }
14212                            params__ = map_.next_value()?;
14213                        }
14214                    }
14215                }
14216                Ok(SetSystemParamResponse {
14217                    params: params__,
14218                })
14219            }
14220        }
14221        deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
14222    }
14223}
14224impl serde::Serialize for SubscribeRequest {
14225    #[allow(deprecated)]
14226    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14227    where
14228        S: serde::Serializer,
14229    {
14230        use serde::ser::SerializeStruct;
14231        let mut len = 0;
14232        if self.subscribe_type != 0 {
14233            len += 1;
14234        }
14235        if self.host.is_some() {
14236            len += 1;
14237        }
14238        if self.worker_id != 0 {
14239            len += 1;
14240        }
14241        let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
14242        if self.subscribe_type != 0 {
14243            let v = SubscribeType::try_from(self.subscribe_type)
14244                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
14245            struct_ser.serialize_field("subscribeType", &v)?;
14246        }
14247        if let Some(v) = self.host.as_ref() {
14248            struct_ser.serialize_field("host", v)?;
14249        }
14250        if self.worker_id != 0 {
14251            struct_ser.serialize_field("workerId", &self.worker_id)?;
14252        }
14253        struct_ser.end()
14254    }
14255}
14256impl<'de> serde::Deserialize<'de> for SubscribeRequest {
14257    #[allow(deprecated)]
14258    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14259    where
14260        D: serde::Deserializer<'de>,
14261    {
14262        const FIELDS: &[&str] = &[
14263            "subscribe_type",
14264            "subscribeType",
14265            "host",
14266            "worker_id",
14267            "workerId",
14268        ];
14269
14270        #[allow(clippy::enum_variant_names)]
14271        enum GeneratedField {
14272            SubscribeType,
14273            Host,
14274            WorkerId,
14275        }
14276        impl<'de> serde::Deserialize<'de> for GeneratedField {
14277            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14278            where
14279                D: serde::Deserializer<'de>,
14280            {
14281                struct GeneratedVisitor;
14282
14283                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14284                    type Value = GeneratedField;
14285
14286                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14287                        write!(formatter, "expected one of: {:?}", &FIELDS)
14288                    }
14289
14290                    #[allow(unused_variables)]
14291                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14292                    where
14293                        E: serde::de::Error,
14294                    {
14295                        match value {
14296                            "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
14297                            "host" => Ok(GeneratedField::Host),
14298                            "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
14299                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14300                        }
14301                    }
14302                }
14303                deserializer.deserialize_identifier(GeneratedVisitor)
14304            }
14305        }
14306        struct GeneratedVisitor;
14307        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14308            type Value = SubscribeRequest;
14309
14310            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14311                formatter.write_str("struct meta.SubscribeRequest")
14312            }
14313
14314            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
14315                where
14316                    V: serde::de::MapAccess<'de>,
14317            {
14318                let mut subscribe_type__ = None;
14319                let mut host__ = None;
14320                let mut worker_id__ = None;
14321                while let Some(k) = map_.next_key()? {
14322                    match k {
14323                        GeneratedField::SubscribeType => {
14324                            if subscribe_type__.is_some() {
14325                                return Err(serde::de::Error::duplicate_field("subscribeType"));
14326                            }
14327                            subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
14328                        }
14329                        GeneratedField::Host => {
14330                            if host__.is_some() {
14331                                return Err(serde::de::Error::duplicate_field("host"));
14332                            }
14333                            host__ = map_.next_value()?;
14334                        }
14335                        GeneratedField::WorkerId => {
14336                            if worker_id__.is_some() {
14337                                return Err(serde::de::Error::duplicate_field("workerId"));
14338                            }
14339                            worker_id__ = 
14340                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14341                            ;
14342                        }
14343                    }
14344                }
14345                Ok(SubscribeRequest {
14346                    subscribe_type: subscribe_type__.unwrap_or_default(),
14347                    host: host__,
14348                    worker_id: worker_id__.unwrap_or_default(),
14349                })
14350            }
14351        }
14352        deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
14353    }
14354}
14355impl serde::Serialize for SubscribeResponse {
14356    #[allow(deprecated)]
14357    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14358    where
14359        S: serde::Serializer,
14360    {
14361        use serde::ser::SerializeStruct;
14362        let mut len = 0;
14363        if self.status.is_some() {
14364            len += 1;
14365        }
14366        if self.operation != 0 {
14367            len += 1;
14368        }
14369        if self.version != 0 {
14370            len += 1;
14371        }
14372        if self.info.is_some() {
14373            len += 1;
14374        }
14375        let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
14376        if let Some(v) = self.status.as_ref() {
14377            struct_ser.serialize_field("status", v)?;
14378        }
14379        if self.operation != 0 {
14380            let v = subscribe_response::Operation::try_from(self.operation)
14381                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
14382            struct_ser.serialize_field("operation", &v)?;
14383        }
14384        if self.version != 0 {
14385            #[allow(clippy::needless_borrow)]
14386            #[allow(clippy::needless_borrows_for_generic_args)]
14387            struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
14388        }
14389        if let Some(v) = self.info.as_ref() {
14390            match v {
14391                subscribe_response::Info::Database(v) => {
14392                    struct_ser.serialize_field("database", v)?;
14393                }
14394                subscribe_response::Info::Schema(v) => {
14395                    struct_ser.serialize_field("schema", v)?;
14396                }
14397                subscribe_response::Info::Function(v) => {
14398                    struct_ser.serialize_field("function", v)?;
14399                }
14400                subscribe_response::Info::User(v) => {
14401                    struct_ser.serialize_field("user", v)?;
14402                }
14403                subscribe_response::Info::SessionParam(v) => {
14404                    struct_ser.serialize_field("sessionParam", v)?;
14405                }
14406                subscribe_response::Info::Node(v) => {
14407                    struct_ser.serialize_field("node", v)?;
14408                }
14409                subscribe_response::Info::HummockVersionDeltas(v) => {
14410                    struct_ser.serialize_field("hummockVersionDeltas", v)?;
14411                }
14412                subscribe_response::Info::Snapshot(v) => {
14413                    struct_ser.serialize_field("snapshot", v)?;
14414                }
14415                subscribe_response::Info::MetaBackupManifestId(v) => {
14416                    struct_ser.serialize_field("metaBackupManifestId", v)?;
14417                }
14418                subscribe_response::Info::SystemParams(v) => {
14419                    struct_ser.serialize_field("systemParams", v)?;
14420                }
14421                subscribe_response::Info::HummockWriteLimits(v) => {
14422                    struct_ser.serialize_field("hummockWriteLimits", v)?;
14423                }
14424                subscribe_response::Info::ObjectGroup(v) => {
14425                    struct_ser.serialize_field("objectGroup", v)?;
14426                }
14427                subscribe_response::Info::Connection(v) => {
14428                    struct_ser.serialize_field("connection", v)?;
14429                }
14430                subscribe_response::Info::HummockStats(v) => {
14431                    struct_ser.serialize_field("hummockStats", v)?;
14432                }
14433                subscribe_response::Info::Recovery(v) => {
14434                    struct_ser.serialize_field("recovery", v)?;
14435                }
14436                subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
14437                    struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
14438                }
14439                subscribe_response::Info::ServingWorkerSlotMappings(v) => {
14440                    struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
14441                }
14442                subscribe_response::Info::Secret(v) => {
14443                    struct_ser.serialize_field("secret", v)?;
14444                }
14445                subscribe_response::Info::ComputeNodeTotalCpuCount(v) => {
14446                    #[allow(clippy::needless_borrow)]
14447                    #[allow(clippy::needless_borrows_for_generic_args)]
14448                    struct_ser.serialize_field("computeNodeTotalCpuCount", ToString::to_string(&v).as_str())?;
14449                }
14450            }
14451        }
14452        struct_ser.end()
14453    }
14454}
14455impl<'de> serde::Deserialize<'de> for SubscribeResponse {
14456    #[allow(deprecated)]
14457    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14458    where
14459        D: serde::Deserializer<'de>,
14460    {
14461        const FIELDS: &[&str] = &[
14462            "status",
14463            "operation",
14464            "version",
14465            "database",
14466            "schema",
14467            "function",
14468            "user",
14469            "session_param",
14470            "sessionParam",
14471            "node",
14472            "hummock_version_deltas",
14473            "hummockVersionDeltas",
14474            "snapshot",
14475            "meta_backup_manifest_id",
14476            "metaBackupManifestId",
14477            "system_params",
14478            "systemParams",
14479            "hummock_write_limits",
14480            "hummockWriteLimits",
14481            "object_group",
14482            "objectGroup",
14483            "connection",
14484            "hummock_stats",
14485            "hummockStats",
14486            "recovery",
14487            "streaming_worker_slot_mapping",
14488            "streamingWorkerSlotMapping",
14489            "serving_worker_slot_mappings",
14490            "servingWorkerSlotMappings",
14491            "secret",
14492            "compute_node_total_cpu_count",
14493            "computeNodeTotalCpuCount",
14494        ];
14495
14496        #[allow(clippy::enum_variant_names)]
14497        enum GeneratedField {
14498            Status,
14499            Operation,
14500            Version,
14501            Database,
14502            Schema,
14503            Function,
14504            User,
14505            SessionParam,
14506            Node,
14507            HummockVersionDeltas,
14508            Snapshot,
14509            MetaBackupManifestId,
14510            SystemParams,
14511            HummockWriteLimits,
14512            ObjectGroup,
14513            Connection,
14514            HummockStats,
14515            Recovery,
14516            StreamingWorkerSlotMapping,
14517            ServingWorkerSlotMappings,
14518            Secret,
14519            ComputeNodeTotalCpuCount,
14520        }
14521        impl<'de> serde::Deserialize<'de> for GeneratedField {
14522            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14523            where
14524                D: serde::Deserializer<'de>,
14525            {
14526                struct GeneratedVisitor;
14527
14528                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14529                    type Value = GeneratedField;
14530
14531                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14532                        write!(formatter, "expected one of: {:?}", &FIELDS)
14533                    }
14534
14535                    #[allow(unused_variables)]
14536                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14537                    where
14538                        E: serde::de::Error,
14539                    {
14540                        match value {
14541                            "status" => Ok(GeneratedField::Status),
14542                            "operation" => Ok(GeneratedField::Operation),
14543                            "version" => Ok(GeneratedField::Version),
14544                            "database" => Ok(GeneratedField::Database),
14545                            "schema" => Ok(GeneratedField::Schema),
14546                            "function" => Ok(GeneratedField::Function),
14547                            "user" => Ok(GeneratedField::User),
14548                            "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
14549                            "node" => Ok(GeneratedField::Node),
14550                            "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
14551                            "snapshot" => Ok(GeneratedField::Snapshot),
14552                            "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
14553                            "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
14554                            "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
14555                            "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
14556                            "connection" => Ok(GeneratedField::Connection),
14557                            "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
14558                            "recovery" => Ok(GeneratedField::Recovery),
14559                            "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
14560                            "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
14561                            "secret" => Ok(GeneratedField::Secret),
14562                            "computeNodeTotalCpuCount" | "compute_node_total_cpu_count" => Ok(GeneratedField::ComputeNodeTotalCpuCount),
14563                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14564                        }
14565                    }
14566                }
14567                deserializer.deserialize_identifier(GeneratedVisitor)
14568            }
14569        }
14570        struct GeneratedVisitor;
14571        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14572            type Value = SubscribeResponse;
14573
14574            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14575                formatter.write_str("struct meta.SubscribeResponse")
14576            }
14577
14578            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
14579                where
14580                    V: serde::de::MapAccess<'de>,
14581            {
14582                let mut status__ = None;
14583                let mut operation__ = None;
14584                let mut version__ = None;
14585                let mut info__ = None;
14586                while let Some(k) = map_.next_key()? {
14587                    match k {
14588                        GeneratedField::Status => {
14589                            if status__.is_some() {
14590                                return Err(serde::de::Error::duplicate_field("status"));
14591                            }
14592                            status__ = map_.next_value()?;
14593                        }
14594                        GeneratedField::Operation => {
14595                            if operation__.is_some() {
14596                                return Err(serde::de::Error::duplicate_field("operation"));
14597                            }
14598                            operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
14599                        }
14600                        GeneratedField::Version => {
14601                            if version__.is_some() {
14602                                return Err(serde::de::Error::duplicate_field("version"));
14603                            }
14604                            version__ = 
14605                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14606                            ;
14607                        }
14608                        GeneratedField::Database => {
14609                            if info__.is_some() {
14610                                return Err(serde::de::Error::duplicate_field("database"));
14611                            }
14612                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
14613;
14614                        }
14615                        GeneratedField::Schema => {
14616                            if info__.is_some() {
14617                                return Err(serde::de::Error::duplicate_field("schema"));
14618                            }
14619                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
14620;
14621                        }
14622                        GeneratedField::Function => {
14623                            if info__.is_some() {
14624                                return Err(serde::de::Error::duplicate_field("function"));
14625                            }
14626                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
14627;
14628                        }
14629                        GeneratedField::User => {
14630                            if info__.is_some() {
14631                                return Err(serde::de::Error::duplicate_field("user"));
14632                            }
14633                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
14634;
14635                        }
14636                        GeneratedField::SessionParam => {
14637                            if info__.is_some() {
14638                                return Err(serde::de::Error::duplicate_field("sessionParam"));
14639                            }
14640                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
14641;
14642                        }
14643                        GeneratedField::Node => {
14644                            if info__.is_some() {
14645                                return Err(serde::de::Error::duplicate_field("node"));
14646                            }
14647                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
14648;
14649                        }
14650                        GeneratedField::HummockVersionDeltas => {
14651                            if info__.is_some() {
14652                                return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
14653                            }
14654                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
14655;
14656                        }
14657                        GeneratedField::Snapshot => {
14658                            if info__.is_some() {
14659                                return Err(serde::de::Error::duplicate_field("snapshot"));
14660                            }
14661                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
14662;
14663                        }
14664                        GeneratedField::MetaBackupManifestId => {
14665                            if info__.is_some() {
14666                                return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
14667                            }
14668                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
14669;
14670                        }
14671                        GeneratedField::SystemParams => {
14672                            if info__.is_some() {
14673                                return Err(serde::de::Error::duplicate_field("systemParams"));
14674                            }
14675                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
14676;
14677                        }
14678                        GeneratedField::HummockWriteLimits => {
14679                            if info__.is_some() {
14680                                return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
14681                            }
14682                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
14683;
14684                        }
14685                        GeneratedField::ObjectGroup => {
14686                            if info__.is_some() {
14687                                return Err(serde::de::Error::duplicate_field("objectGroup"));
14688                            }
14689                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
14690;
14691                        }
14692                        GeneratedField::Connection => {
14693                            if info__.is_some() {
14694                                return Err(serde::de::Error::duplicate_field("connection"));
14695                            }
14696                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
14697;
14698                        }
14699                        GeneratedField::HummockStats => {
14700                            if info__.is_some() {
14701                                return Err(serde::de::Error::duplicate_field("hummockStats"));
14702                            }
14703                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
14704;
14705                        }
14706                        GeneratedField::Recovery => {
14707                            if info__.is_some() {
14708                                return Err(serde::de::Error::duplicate_field("recovery"));
14709                            }
14710                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
14711;
14712                        }
14713                        GeneratedField::StreamingWorkerSlotMapping => {
14714                            if info__.is_some() {
14715                                return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
14716                            }
14717                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
14718;
14719                        }
14720                        GeneratedField::ServingWorkerSlotMappings => {
14721                            if info__.is_some() {
14722                                return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
14723                            }
14724                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
14725;
14726                        }
14727                        GeneratedField::Secret => {
14728                            if info__.is_some() {
14729                                return Err(serde::de::Error::duplicate_field("secret"));
14730                            }
14731                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
14732;
14733                        }
14734                        GeneratedField::ComputeNodeTotalCpuCount => {
14735                            if info__.is_some() {
14736                                return Err(serde::de::Error::duplicate_field("computeNodeTotalCpuCount"));
14737                            }
14738                            info__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| subscribe_response::Info::ComputeNodeTotalCpuCount(x.0));
14739                        }
14740                    }
14741                }
14742                Ok(SubscribeResponse {
14743                    status: status__,
14744                    operation: operation__.unwrap_or_default(),
14745                    version: version__.unwrap_or_default(),
14746                    info: info__,
14747                })
14748            }
14749        }
14750        deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
14751    }
14752}
14753impl serde::Serialize for subscribe_response::Operation {
14754    #[allow(deprecated)]
14755    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14756    where
14757        S: serde::Serializer,
14758    {
14759        let variant = match self {
14760            Self::Unspecified => "UNSPECIFIED",
14761            Self::Add => "ADD",
14762            Self::Delete => "DELETE",
14763            Self::Update => "UPDATE",
14764            Self::Snapshot => "SNAPSHOT",
14765        };
14766        serializer.serialize_str(variant)
14767    }
14768}
14769impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
14770    #[allow(deprecated)]
14771    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14772    where
14773        D: serde::Deserializer<'de>,
14774    {
14775        const FIELDS: &[&str] = &[
14776            "UNSPECIFIED",
14777            "ADD",
14778            "DELETE",
14779            "UPDATE",
14780            "SNAPSHOT",
14781        ];
14782
14783        struct GeneratedVisitor;
14784
14785        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14786            type Value = subscribe_response::Operation;
14787
14788            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14789                write!(formatter, "expected one of: {:?}", &FIELDS)
14790            }
14791
14792            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14793            where
14794                E: serde::de::Error,
14795            {
14796                i32::try_from(v)
14797                    .ok()
14798                    .and_then(|x| x.try_into().ok())
14799                    .ok_or_else(|| {
14800                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14801                    })
14802            }
14803
14804            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14805            where
14806                E: serde::de::Error,
14807            {
14808                i32::try_from(v)
14809                    .ok()
14810                    .and_then(|x| x.try_into().ok())
14811                    .ok_or_else(|| {
14812                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14813                    })
14814            }
14815
14816            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14817            where
14818                E: serde::de::Error,
14819            {
14820                match value {
14821                    "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
14822                    "ADD" => Ok(subscribe_response::Operation::Add),
14823                    "DELETE" => Ok(subscribe_response::Operation::Delete),
14824                    "UPDATE" => Ok(subscribe_response::Operation::Update),
14825                    "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
14826                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14827                }
14828            }
14829        }
14830        deserializer.deserialize_any(GeneratedVisitor)
14831    }
14832}
14833impl serde::Serialize for SubscribeType {
14834    #[allow(deprecated)]
14835    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14836    where
14837        S: serde::Serializer,
14838    {
14839        let variant = match self {
14840            Self::Unspecified => "UNSPECIFIED",
14841            Self::Frontend => "FRONTEND",
14842            Self::Hummock => "HUMMOCK",
14843            Self::Compactor => "COMPACTOR",
14844            Self::Compute => "COMPUTE",
14845        };
14846        serializer.serialize_str(variant)
14847    }
14848}
14849impl<'de> serde::Deserialize<'de> for SubscribeType {
14850    #[allow(deprecated)]
14851    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14852    where
14853        D: serde::Deserializer<'de>,
14854    {
14855        const FIELDS: &[&str] = &[
14856            "UNSPECIFIED",
14857            "FRONTEND",
14858            "HUMMOCK",
14859            "COMPACTOR",
14860            "COMPUTE",
14861        ];
14862
14863        struct GeneratedVisitor;
14864
14865        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14866            type Value = SubscribeType;
14867
14868            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14869                write!(formatter, "expected one of: {:?}", &FIELDS)
14870            }
14871
14872            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14873            where
14874                E: serde::de::Error,
14875            {
14876                i32::try_from(v)
14877                    .ok()
14878                    .and_then(|x| x.try_into().ok())
14879                    .ok_or_else(|| {
14880                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14881                    })
14882            }
14883
14884            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14885            where
14886                E: serde::de::Error,
14887            {
14888                i32::try_from(v)
14889                    .ok()
14890                    .and_then(|x| x.try_into().ok())
14891                    .ok_or_else(|| {
14892                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14893                    })
14894            }
14895
14896            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14897            where
14898                E: serde::de::Error,
14899            {
14900                match value {
14901                    "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
14902                    "FRONTEND" => Ok(SubscribeType::Frontend),
14903                    "HUMMOCK" => Ok(SubscribeType::Hummock),
14904                    "COMPACTOR" => Ok(SubscribeType::Compactor),
14905                    "COMPUTE" => Ok(SubscribeType::Compute),
14906                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14907                }
14908            }
14909        }
14910        deserializer.deserialize_any(GeneratedVisitor)
14911    }
14912}
14913impl serde::Serialize for SystemParams {
14914    #[allow(deprecated)]
14915    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14916    where
14917        S: serde::Serializer,
14918    {
14919        use serde::ser::SerializeStruct;
14920        let mut len = 0;
14921        if self.barrier_interval_ms.is_some() {
14922            len += 1;
14923        }
14924        if self.checkpoint_frequency.is_some() {
14925            len += 1;
14926        }
14927        if self.sstable_size_mb.is_some() {
14928            len += 1;
14929        }
14930        if self.block_size_kb.is_some() {
14931            len += 1;
14932        }
14933        if self.bloom_false_positive.is_some() {
14934            len += 1;
14935        }
14936        if self.state_store.is_some() {
14937            len += 1;
14938        }
14939        if self.data_directory.is_some() {
14940            len += 1;
14941        }
14942        if self.backup_storage_url.is_some() {
14943            len += 1;
14944        }
14945        if self.backup_storage_directory.is_some() {
14946            len += 1;
14947        }
14948        if self.telemetry_enabled.is_some() {
14949            len += 1;
14950        }
14951        if self.parallel_compact_size_mb.is_some() {
14952            len += 1;
14953        }
14954        if self.max_concurrent_creating_streaming_jobs.is_some() {
14955            len += 1;
14956        }
14957        if self.pause_on_next_bootstrap.is_some() {
14958            len += 1;
14959        }
14960        if self.wasm_storage_url.is_some() {
14961            len += 1;
14962        }
14963        if self.enable_tracing.is_some() {
14964            len += 1;
14965        }
14966        if self.use_new_object_prefix_strategy.is_some() {
14967            len += 1;
14968        }
14969        if self.license_key.is_some() {
14970            len += 1;
14971        }
14972        if self.time_travel_retention_ms.is_some() {
14973            len += 1;
14974        }
14975        if self.adaptive_parallelism_strategy.is_some() {
14976            len += 1;
14977        }
14978        if self.per_database_isolation.is_some() {
14979            len += 1;
14980        }
14981        if self.enforce_secret.is_some() {
14982            len += 1;
14983        }
14984        let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
14985        if let Some(v) = self.barrier_interval_ms.as_ref() {
14986            struct_ser.serialize_field("barrierIntervalMs", v)?;
14987        }
14988        if let Some(v) = self.checkpoint_frequency.as_ref() {
14989            #[allow(clippy::needless_borrow)]
14990            #[allow(clippy::needless_borrows_for_generic_args)]
14991            struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
14992        }
14993        if let Some(v) = self.sstable_size_mb.as_ref() {
14994            struct_ser.serialize_field("sstableSizeMb", v)?;
14995        }
14996        if let Some(v) = self.block_size_kb.as_ref() {
14997            struct_ser.serialize_field("blockSizeKb", v)?;
14998        }
14999        if let Some(v) = self.bloom_false_positive.as_ref() {
15000            struct_ser.serialize_field("bloomFalsePositive", v)?;
15001        }
15002        if let Some(v) = self.state_store.as_ref() {
15003            struct_ser.serialize_field("stateStore", v)?;
15004        }
15005        if let Some(v) = self.data_directory.as_ref() {
15006            struct_ser.serialize_field("dataDirectory", v)?;
15007        }
15008        if let Some(v) = self.backup_storage_url.as_ref() {
15009            struct_ser.serialize_field("backupStorageUrl", v)?;
15010        }
15011        if let Some(v) = self.backup_storage_directory.as_ref() {
15012            struct_ser.serialize_field("backupStorageDirectory", v)?;
15013        }
15014        if let Some(v) = self.telemetry_enabled.as_ref() {
15015            struct_ser.serialize_field("telemetryEnabled", v)?;
15016        }
15017        if let Some(v) = self.parallel_compact_size_mb.as_ref() {
15018            struct_ser.serialize_field("parallelCompactSizeMb", v)?;
15019        }
15020        if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
15021            struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
15022        }
15023        if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
15024            struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
15025        }
15026        if let Some(v) = self.wasm_storage_url.as_ref() {
15027            struct_ser.serialize_field("wasmStorageUrl", v)?;
15028        }
15029        if let Some(v) = self.enable_tracing.as_ref() {
15030            struct_ser.serialize_field("enableTracing", v)?;
15031        }
15032        if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
15033            struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
15034        }
15035        if let Some(v) = self.license_key.as_ref() {
15036            struct_ser.serialize_field("licenseKey", v)?;
15037        }
15038        if let Some(v) = self.time_travel_retention_ms.as_ref() {
15039            #[allow(clippy::needless_borrow)]
15040            #[allow(clippy::needless_borrows_for_generic_args)]
15041            struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
15042        }
15043        if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
15044            struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
15045        }
15046        if let Some(v) = self.per_database_isolation.as_ref() {
15047            struct_ser.serialize_field("perDatabaseIsolation", v)?;
15048        }
15049        if let Some(v) = self.enforce_secret.as_ref() {
15050            struct_ser.serialize_field("enforceSecret", v)?;
15051        }
15052        struct_ser.end()
15053    }
15054}
15055impl<'de> serde::Deserialize<'de> for SystemParams {
15056    #[allow(deprecated)]
15057    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15058    where
15059        D: serde::Deserializer<'de>,
15060    {
15061        const FIELDS: &[&str] = &[
15062            "barrier_interval_ms",
15063            "barrierIntervalMs",
15064            "checkpoint_frequency",
15065            "checkpointFrequency",
15066            "sstable_size_mb",
15067            "sstableSizeMb",
15068            "block_size_kb",
15069            "blockSizeKb",
15070            "bloom_false_positive",
15071            "bloomFalsePositive",
15072            "state_store",
15073            "stateStore",
15074            "data_directory",
15075            "dataDirectory",
15076            "backup_storage_url",
15077            "backupStorageUrl",
15078            "backup_storage_directory",
15079            "backupStorageDirectory",
15080            "telemetry_enabled",
15081            "telemetryEnabled",
15082            "parallel_compact_size_mb",
15083            "parallelCompactSizeMb",
15084            "max_concurrent_creating_streaming_jobs",
15085            "maxConcurrentCreatingStreamingJobs",
15086            "pause_on_next_bootstrap",
15087            "pauseOnNextBootstrap",
15088            "wasm_storage_url",
15089            "wasmStorageUrl",
15090            "enable_tracing",
15091            "enableTracing",
15092            "use_new_object_prefix_strategy",
15093            "useNewObjectPrefixStrategy",
15094            "license_key",
15095            "licenseKey",
15096            "time_travel_retention_ms",
15097            "timeTravelRetentionMs",
15098            "adaptive_parallelism_strategy",
15099            "adaptiveParallelismStrategy",
15100            "per_database_isolation",
15101            "perDatabaseIsolation",
15102            "enforce_secret",
15103            "enforceSecret",
15104        ];
15105
15106        #[allow(clippy::enum_variant_names)]
15107        enum GeneratedField {
15108            BarrierIntervalMs,
15109            CheckpointFrequency,
15110            SstableSizeMb,
15111            BlockSizeKb,
15112            BloomFalsePositive,
15113            StateStore,
15114            DataDirectory,
15115            BackupStorageUrl,
15116            BackupStorageDirectory,
15117            TelemetryEnabled,
15118            ParallelCompactSizeMb,
15119            MaxConcurrentCreatingStreamingJobs,
15120            PauseOnNextBootstrap,
15121            WasmStorageUrl,
15122            EnableTracing,
15123            UseNewObjectPrefixStrategy,
15124            LicenseKey,
15125            TimeTravelRetentionMs,
15126            AdaptiveParallelismStrategy,
15127            PerDatabaseIsolation,
15128            EnforceSecret,
15129        }
15130        impl<'de> serde::Deserialize<'de> for GeneratedField {
15131            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15132            where
15133                D: serde::Deserializer<'de>,
15134            {
15135                struct GeneratedVisitor;
15136
15137                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15138                    type Value = GeneratedField;
15139
15140                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15141                        write!(formatter, "expected one of: {:?}", &FIELDS)
15142                    }
15143
15144                    #[allow(unused_variables)]
15145                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15146                    where
15147                        E: serde::de::Error,
15148                    {
15149                        match value {
15150                            "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
15151                            "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
15152                            "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
15153                            "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
15154                            "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
15155                            "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
15156                            "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
15157                            "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
15158                            "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
15159                            "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
15160                            "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
15161                            "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
15162                            "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
15163                            "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
15164                            "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
15165                            "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
15166                            "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
15167                            "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
15168                            "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
15169                            "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
15170                            "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
15171                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15172                        }
15173                    }
15174                }
15175                deserializer.deserialize_identifier(GeneratedVisitor)
15176            }
15177        }
15178        struct GeneratedVisitor;
15179        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15180            type Value = SystemParams;
15181
15182            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15183                formatter.write_str("struct meta.SystemParams")
15184            }
15185
15186            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
15187                where
15188                    V: serde::de::MapAccess<'de>,
15189            {
15190                let mut barrier_interval_ms__ = None;
15191                let mut checkpoint_frequency__ = None;
15192                let mut sstable_size_mb__ = None;
15193                let mut block_size_kb__ = None;
15194                let mut bloom_false_positive__ = None;
15195                let mut state_store__ = None;
15196                let mut data_directory__ = None;
15197                let mut backup_storage_url__ = None;
15198                let mut backup_storage_directory__ = None;
15199                let mut telemetry_enabled__ = None;
15200                let mut parallel_compact_size_mb__ = None;
15201                let mut max_concurrent_creating_streaming_jobs__ = None;
15202                let mut pause_on_next_bootstrap__ = None;
15203                let mut wasm_storage_url__ = None;
15204                let mut enable_tracing__ = None;
15205                let mut use_new_object_prefix_strategy__ = None;
15206                let mut license_key__ = None;
15207                let mut time_travel_retention_ms__ = None;
15208                let mut adaptive_parallelism_strategy__ = None;
15209                let mut per_database_isolation__ = None;
15210                let mut enforce_secret__ = None;
15211                while let Some(k) = map_.next_key()? {
15212                    match k {
15213                        GeneratedField::BarrierIntervalMs => {
15214                            if barrier_interval_ms__.is_some() {
15215                                return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
15216                            }
15217                            barrier_interval_ms__ = 
15218                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15219                            ;
15220                        }
15221                        GeneratedField::CheckpointFrequency => {
15222                            if checkpoint_frequency__.is_some() {
15223                                return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
15224                            }
15225                            checkpoint_frequency__ = 
15226                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15227                            ;
15228                        }
15229                        GeneratedField::SstableSizeMb => {
15230                            if sstable_size_mb__.is_some() {
15231                                return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
15232                            }
15233                            sstable_size_mb__ = 
15234                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15235                            ;
15236                        }
15237                        GeneratedField::BlockSizeKb => {
15238                            if block_size_kb__.is_some() {
15239                                return Err(serde::de::Error::duplicate_field("blockSizeKb"));
15240                            }
15241                            block_size_kb__ = 
15242                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15243                            ;
15244                        }
15245                        GeneratedField::BloomFalsePositive => {
15246                            if bloom_false_positive__.is_some() {
15247                                return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
15248                            }
15249                            bloom_false_positive__ = 
15250                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15251                            ;
15252                        }
15253                        GeneratedField::StateStore => {
15254                            if state_store__.is_some() {
15255                                return Err(serde::de::Error::duplicate_field("stateStore"));
15256                            }
15257                            state_store__ = map_.next_value()?;
15258                        }
15259                        GeneratedField::DataDirectory => {
15260                            if data_directory__.is_some() {
15261                                return Err(serde::de::Error::duplicate_field("dataDirectory"));
15262                            }
15263                            data_directory__ = map_.next_value()?;
15264                        }
15265                        GeneratedField::BackupStorageUrl => {
15266                            if backup_storage_url__.is_some() {
15267                                return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
15268                            }
15269                            backup_storage_url__ = map_.next_value()?;
15270                        }
15271                        GeneratedField::BackupStorageDirectory => {
15272                            if backup_storage_directory__.is_some() {
15273                                return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
15274                            }
15275                            backup_storage_directory__ = map_.next_value()?;
15276                        }
15277                        GeneratedField::TelemetryEnabled => {
15278                            if telemetry_enabled__.is_some() {
15279                                return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
15280                            }
15281                            telemetry_enabled__ = map_.next_value()?;
15282                        }
15283                        GeneratedField::ParallelCompactSizeMb => {
15284                            if parallel_compact_size_mb__.is_some() {
15285                                return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
15286                            }
15287                            parallel_compact_size_mb__ = 
15288                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15289                            ;
15290                        }
15291                        GeneratedField::MaxConcurrentCreatingStreamingJobs => {
15292                            if max_concurrent_creating_streaming_jobs__.is_some() {
15293                                return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
15294                            }
15295                            max_concurrent_creating_streaming_jobs__ = 
15296                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15297                            ;
15298                        }
15299                        GeneratedField::PauseOnNextBootstrap => {
15300                            if pause_on_next_bootstrap__.is_some() {
15301                                return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
15302                            }
15303                            pause_on_next_bootstrap__ = map_.next_value()?;
15304                        }
15305                        GeneratedField::WasmStorageUrl => {
15306                            if wasm_storage_url__.is_some() {
15307                                return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
15308                            }
15309                            wasm_storage_url__ = map_.next_value()?;
15310                        }
15311                        GeneratedField::EnableTracing => {
15312                            if enable_tracing__.is_some() {
15313                                return Err(serde::de::Error::duplicate_field("enableTracing"));
15314                            }
15315                            enable_tracing__ = map_.next_value()?;
15316                        }
15317                        GeneratedField::UseNewObjectPrefixStrategy => {
15318                            if use_new_object_prefix_strategy__.is_some() {
15319                                return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
15320                            }
15321                            use_new_object_prefix_strategy__ = map_.next_value()?;
15322                        }
15323                        GeneratedField::LicenseKey => {
15324                            if license_key__.is_some() {
15325                                return Err(serde::de::Error::duplicate_field("licenseKey"));
15326                            }
15327                            license_key__ = map_.next_value()?;
15328                        }
15329                        GeneratedField::TimeTravelRetentionMs => {
15330                            if time_travel_retention_ms__.is_some() {
15331                                return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
15332                            }
15333                            time_travel_retention_ms__ = 
15334                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15335                            ;
15336                        }
15337                        GeneratedField::AdaptiveParallelismStrategy => {
15338                            if adaptive_parallelism_strategy__.is_some() {
15339                                return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
15340                            }
15341                            adaptive_parallelism_strategy__ = map_.next_value()?;
15342                        }
15343                        GeneratedField::PerDatabaseIsolation => {
15344                            if per_database_isolation__.is_some() {
15345                                return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
15346                            }
15347                            per_database_isolation__ = map_.next_value()?;
15348                        }
15349                        GeneratedField::EnforceSecret => {
15350                            if enforce_secret__.is_some() {
15351                                return Err(serde::de::Error::duplicate_field("enforceSecret"));
15352                            }
15353                            enforce_secret__ = map_.next_value()?;
15354                        }
15355                    }
15356                }
15357                Ok(SystemParams {
15358                    barrier_interval_ms: barrier_interval_ms__,
15359                    checkpoint_frequency: checkpoint_frequency__,
15360                    sstable_size_mb: sstable_size_mb__,
15361                    block_size_kb: block_size_kb__,
15362                    bloom_false_positive: bloom_false_positive__,
15363                    state_store: state_store__,
15364                    data_directory: data_directory__,
15365                    backup_storage_url: backup_storage_url__,
15366                    backup_storage_directory: backup_storage_directory__,
15367                    telemetry_enabled: telemetry_enabled__,
15368                    parallel_compact_size_mb: parallel_compact_size_mb__,
15369                    max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
15370                    pause_on_next_bootstrap: pause_on_next_bootstrap__,
15371                    wasm_storage_url: wasm_storage_url__,
15372                    enable_tracing: enable_tracing__,
15373                    use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
15374                    license_key: license_key__,
15375                    time_travel_retention_ms: time_travel_retention_ms__,
15376                    adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
15377                    per_database_isolation: per_database_isolation__,
15378                    enforce_secret: enforce_secret__,
15379                })
15380            }
15381        }
15382        deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
15383    }
15384}
15385impl serde::Serialize for TableFragments {
15386    #[allow(deprecated)]
15387    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15388    where
15389        S: serde::Serializer,
15390    {
15391        use serde::ser::SerializeStruct;
15392        let mut len = 0;
15393        if self.table_id != 0 {
15394            len += 1;
15395        }
15396        if self.state != 0 {
15397            len += 1;
15398        }
15399        if !self.fragments.is_empty() {
15400            len += 1;
15401        }
15402        if !self.actor_status.is_empty() {
15403            len += 1;
15404        }
15405        if !self.actor_splits.is_empty() {
15406            len += 1;
15407        }
15408        if self.ctx.is_some() {
15409            len += 1;
15410        }
15411        if self.parallelism.is_some() {
15412            len += 1;
15413        }
15414        if self.max_parallelism.is_some() {
15415            len += 1;
15416        }
15417        if !self.node_label.is_empty() {
15418            len += 1;
15419        }
15420        if self.backfill_done {
15421            len += 1;
15422        }
15423        let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
15424        if self.table_id != 0 {
15425            struct_ser.serialize_field("tableId", &self.table_id)?;
15426        }
15427        if self.state != 0 {
15428            let v = table_fragments::State::try_from(self.state)
15429                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
15430            struct_ser.serialize_field("state", &v)?;
15431        }
15432        if !self.fragments.is_empty() {
15433            struct_ser.serialize_field("fragments", &self.fragments)?;
15434        }
15435        if !self.actor_status.is_empty() {
15436            struct_ser.serialize_field("actorStatus", &self.actor_status)?;
15437        }
15438        if !self.actor_splits.is_empty() {
15439            struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
15440        }
15441        if let Some(v) = self.ctx.as_ref() {
15442            struct_ser.serialize_field("ctx", v)?;
15443        }
15444        if let Some(v) = self.parallelism.as_ref() {
15445            struct_ser.serialize_field("parallelism", v)?;
15446        }
15447        if let Some(v) = self.max_parallelism.as_ref() {
15448            struct_ser.serialize_field("maxParallelism", v)?;
15449        }
15450        if !self.node_label.is_empty() {
15451            struct_ser.serialize_field("nodeLabel", &self.node_label)?;
15452        }
15453        if self.backfill_done {
15454            struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
15455        }
15456        struct_ser.end()
15457    }
15458}
15459impl<'de> serde::Deserialize<'de> for TableFragments {
15460    #[allow(deprecated)]
15461    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15462    where
15463        D: serde::Deserializer<'de>,
15464    {
15465        const FIELDS: &[&str] = &[
15466            "table_id",
15467            "tableId",
15468            "state",
15469            "fragments",
15470            "actor_status",
15471            "actorStatus",
15472            "actor_splits",
15473            "actorSplits",
15474            "ctx",
15475            "parallelism",
15476            "max_parallelism",
15477            "maxParallelism",
15478            "node_label",
15479            "nodeLabel",
15480            "backfill_done",
15481            "backfillDone",
15482        ];
15483
15484        #[allow(clippy::enum_variant_names)]
15485        enum GeneratedField {
15486            TableId,
15487            State,
15488            Fragments,
15489            ActorStatus,
15490            ActorSplits,
15491            Ctx,
15492            Parallelism,
15493            MaxParallelism,
15494            NodeLabel,
15495            BackfillDone,
15496        }
15497        impl<'de> serde::Deserialize<'de> for GeneratedField {
15498            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15499            where
15500                D: serde::Deserializer<'de>,
15501            {
15502                struct GeneratedVisitor;
15503
15504                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15505                    type Value = GeneratedField;
15506
15507                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15508                        write!(formatter, "expected one of: {:?}", &FIELDS)
15509                    }
15510
15511                    #[allow(unused_variables)]
15512                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15513                    where
15514                        E: serde::de::Error,
15515                    {
15516                        match value {
15517                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
15518                            "state" => Ok(GeneratedField::State),
15519                            "fragments" => Ok(GeneratedField::Fragments),
15520                            "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
15521                            "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
15522                            "ctx" => Ok(GeneratedField::Ctx),
15523                            "parallelism" => Ok(GeneratedField::Parallelism),
15524                            "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
15525                            "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
15526                            "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
15527                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15528                        }
15529                    }
15530                }
15531                deserializer.deserialize_identifier(GeneratedVisitor)
15532            }
15533        }
15534        struct GeneratedVisitor;
15535        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15536            type Value = TableFragments;
15537
15538            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15539                formatter.write_str("struct meta.TableFragments")
15540            }
15541
15542            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
15543                where
15544                    V: serde::de::MapAccess<'de>,
15545            {
15546                let mut table_id__ = None;
15547                let mut state__ = None;
15548                let mut fragments__ = None;
15549                let mut actor_status__ = None;
15550                let mut actor_splits__ = None;
15551                let mut ctx__ = None;
15552                let mut parallelism__ = None;
15553                let mut max_parallelism__ = None;
15554                let mut node_label__ = None;
15555                let mut backfill_done__ = None;
15556                while let Some(k) = map_.next_key()? {
15557                    match k {
15558                        GeneratedField::TableId => {
15559                            if table_id__.is_some() {
15560                                return Err(serde::de::Error::duplicate_field("tableId"));
15561                            }
15562                            table_id__ = 
15563                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15564                            ;
15565                        }
15566                        GeneratedField::State => {
15567                            if state__.is_some() {
15568                                return Err(serde::de::Error::duplicate_field("state"));
15569                            }
15570                            state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
15571                        }
15572                        GeneratedField::Fragments => {
15573                            if fragments__.is_some() {
15574                                return Err(serde::de::Error::duplicate_field("fragments"));
15575                            }
15576                            fragments__ = Some(
15577                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15578                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
15579                            );
15580                        }
15581                        GeneratedField::ActorStatus => {
15582                            if actor_status__.is_some() {
15583                                return Err(serde::de::Error::duplicate_field("actorStatus"));
15584                            }
15585                            actor_status__ = Some(
15586                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15587                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
15588                            );
15589                        }
15590                        GeneratedField::ActorSplits => {
15591                            if actor_splits__.is_some() {
15592                                return Err(serde::de::Error::duplicate_field("actorSplits"));
15593                            }
15594                            actor_splits__ = Some(
15595                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15596                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
15597                            );
15598                        }
15599                        GeneratedField::Ctx => {
15600                            if ctx__.is_some() {
15601                                return Err(serde::de::Error::duplicate_field("ctx"));
15602                            }
15603                            ctx__ = map_.next_value()?;
15604                        }
15605                        GeneratedField::Parallelism => {
15606                            if parallelism__.is_some() {
15607                                return Err(serde::de::Error::duplicate_field("parallelism"));
15608                            }
15609                            parallelism__ = map_.next_value()?;
15610                        }
15611                        GeneratedField::MaxParallelism => {
15612                            if max_parallelism__.is_some() {
15613                                return Err(serde::de::Error::duplicate_field("maxParallelism"));
15614                            }
15615                            max_parallelism__ = 
15616                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15617                            ;
15618                        }
15619                        GeneratedField::NodeLabel => {
15620                            if node_label__.is_some() {
15621                                return Err(serde::de::Error::duplicate_field("nodeLabel"));
15622                            }
15623                            node_label__ = Some(map_.next_value()?);
15624                        }
15625                        GeneratedField::BackfillDone => {
15626                            if backfill_done__.is_some() {
15627                                return Err(serde::de::Error::duplicate_field("backfillDone"));
15628                            }
15629                            backfill_done__ = Some(map_.next_value()?);
15630                        }
15631                    }
15632                }
15633                Ok(TableFragments {
15634                    table_id: table_id__.unwrap_or_default(),
15635                    state: state__.unwrap_or_default(),
15636                    fragments: fragments__.unwrap_or_default(),
15637                    actor_status: actor_status__.unwrap_or_default(),
15638                    actor_splits: actor_splits__.unwrap_or_default(),
15639                    ctx: ctx__,
15640                    parallelism: parallelism__,
15641                    max_parallelism: max_parallelism__,
15642                    node_label: node_label__.unwrap_or_default(),
15643                    backfill_done: backfill_done__.unwrap_or_default(),
15644                })
15645            }
15646        }
15647        deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
15648    }
15649}
15650impl serde::Serialize for table_fragments::ActorStatus {
15651    #[allow(deprecated)]
15652    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15653    where
15654        S: serde::Serializer,
15655    {
15656        use serde::ser::SerializeStruct;
15657        let mut len = 0;
15658        if self.location.is_some() {
15659            len += 1;
15660        }
15661        if self.state != 0 {
15662            len += 1;
15663        }
15664        let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
15665        if let Some(v) = self.location.as_ref() {
15666            struct_ser.serialize_field("location", v)?;
15667        }
15668        if self.state != 0 {
15669            let v = table_fragments::actor_status::ActorState::try_from(self.state)
15670                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
15671            struct_ser.serialize_field("state", &v)?;
15672        }
15673        struct_ser.end()
15674    }
15675}
15676impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
15677    #[allow(deprecated)]
15678    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15679    where
15680        D: serde::Deserializer<'de>,
15681    {
15682        const FIELDS: &[&str] = &[
15683            "location",
15684            "state",
15685        ];
15686
15687        #[allow(clippy::enum_variant_names)]
15688        enum GeneratedField {
15689            Location,
15690            State,
15691        }
15692        impl<'de> serde::Deserialize<'de> for GeneratedField {
15693            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15694            where
15695                D: serde::Deserializer<'de>,
15696            {
15697                struct GeneratedVisitor;
15698
15699                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15700                    type Value = GeneratedField;
15701
15702                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15703                        write!(formatter, "expected one of: {:?}", &FIELDS)
15704                    }
15705
15706                    #[allow(unused_variables)]
15707                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15708                    where
15709                        E: serde::de::Error,
15710                    {
15711                        match value {
15712                            "location" => Ok(GeneratedField::Location),
15713                            "state" => Ok(GeneratedField::State),
15714                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15715                        }
15716                    }
15717                }
15718                deserializer.deserialize_identifier(GeneratedVisitor)
15719            }
15720        }
15721        struct GeneratedVisitor;
15722        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15723            type Value = table_fragments::ActorStatus;
15724
15725            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15726                formatter.write_str("struct meta.TableFragments.ActorStatus")
15727            }
15728
15729            fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
15730                where
15731                    V: serde::de::MapAccess<'de>,
15732            {
15733                let mut location__ = None;
15734                let mut state__ = None;
15735                while let Some(k) = map_.next_key()? {
15736                    match k {
15737                        GeneratedField::Location => {
15738                            if location__.is_some() {
15739                                return Err(serde::de::Error::duplicate_field("location"));
15740                            }
15741                            location__ = map_.next_value()?;
15742                        }
15743                        GeneratedField::State => {
15744                            if state__.is_some() {
15745                                return Err(serde::de::Error::duplicate_field("state"));
15746                            }
15747                            state__ = Some(map_.next_value::<table_fragments::actor_status::ActorState>()? as i32);
15748                        }
15749                    }
15750                }
15751                Ok(table_fragments::ActorStatus {
15752                    location: location__,
15753                    state: state__.unwrap_or_default(),
15754                })
15755            }
15756        }
15757        deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
15758    }
15759}
15760impl serde::Serialize for table_fragments::actor_status::ActorState {
15761    #[allow(deprecated)]
15762    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15763    where
15764        S: serde::Serializer,
15765    {
15766        let variant = match self {
15767            Self::Unspecified => "UNSPECIFIED",
15768            Self::Inactive => "INACTIVE",
15769            Self::Running => "RUNNING",
15770        };
15771        serializer.serialize_str(variant)
15772    }
15773}
15774impl<'de> serde::Deserialize<'de> for table_fragments::actor_status::ActorState {
15775    #[allow(deprecated)]
15776    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15777    where
15778        D: serde::Deserializer<'de>,
15779    {
15780        const FIELDS: &[&str] = &[
15781            "UNSPECIFIED",
15782            "INACTIVE",
15783            "RUNNING",
15784        ];
15785
15786        struct GeneratedVisitor;
15787
15788        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15789            type Value = table_fragments::actor_status::ActorState;
15790
15791            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15792                write!(formatter, "expected one of: {:?}", &FIELDS)
15793            }
15794
15795            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15796            where
15797                E: serde::de::Error,
15798            {
15799                i32::try_from(v)
15800                    .ok()
15801                    .and_then(|x| x.try_into().ok())
15802                    .ok_or_else(|| {
15803                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15804                    })
15805            }
15806
15807            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15808            where
15809                E: serde::de::Error,
15810            {
15811                i32::try_from(v)
15812                    .ok()
15813                    .and_then(|x| x.try_into().ok())
15814                    .ok_or_else(|| {
15815                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15816                    })
15817            }
15818
15819            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15820            where
15821                E: serde::de::Error,
15822            {
15823                match value {
15824                    "UNSPECIFIED" => Ok(table_fragments::actor_status::ActorState::Unspecified),
15825                    "INACTIVE" => Ok(table_fragments::actor_status::ActorState::Inactive),
15826                    "RUNNING" => Ok(table_fragments::actor_status::ActorState::Running),
15827                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15828                }
15829            }
15830        }
15831        deserializer.deserialize_any(GeneratedVisitor)
15832    }
15833}
15834impl serde::Serialize for table_fragments::Fragment {
15835    #[allow(deprecated)]
15836    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15837    where
15838        S: serde::Serializer,
15839    {
15840        use serde::ser::SerializeStruct;
15841        let mut len = 0;
15842        if self.fragment_id != 0 {
15843            len += 1;
15844        }
15845        if self.fragment_type_mask != 0 {
15846            len += 1;
15847        }
15848        if self.distribution_type != 0 {
15849            len += 1;
15850        }
15851        if !self.actors.is_empty() {
15852            len += 1;
15853        }
15854        if !self.state_table_ids.is_empty() {
15855            len += 1;
15856        }
15857        if !self.upstream_fragment_ids.is_empty() {
15858            len += 1;
15859        }
15860        if self.maybe_vnode_count.is_some() {
15861            len += 1;
15862        }
15863        if self.nodes.is_some() {
15864            len += 1;
15865        }
15866        let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
15867        if self.fragment_id != 0 {
15868            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
15869        }
15870        if self.fragment_type_mask != 0 {
15871            struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
15872        }
15873        if self.distribution_type != 0 {
15874            let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
15875                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
15876            struct_ser.serialize_field("distributionType", &v)?;
15877        }
15878        if !self.actors.is_empty() {
15879            struct_ser.serialize_field("actors", &self.actors)?;
15880        }
15881        if !self.state_table_ids.is_empty() {
15882            struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
15883        }
15884        if !self.upstream_fragment_ids.is_empty() {
15885            struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
15886        }
15887        if let Some(v) = self.maybe_vnode_count.as_ref() {
15888            struct_ser.serialize_field("maybeVnodeCount", v)?;
15889        }
15890        if let Some(v) = self.nodes.as_ref() {
15891            struct_ser.serialize_field("nodes", v)?;
15892        }
15893        struct_ser.end()
15894    }
15895}
15896impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
15897    #[allow(deprecated)]
15898    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15899    where
15900        D: serde::Deserializer<'de>,
15901    {
15902        const FIELDS: &[&str] = &[
15903            "fragment_id",
15904            "fragmentId",
15905            "fragment_type_mask",
15906            "fragmentTypeMask",
15907            "distribution_type",
15908            "distributionType",
15909            "actors",
15910            "state_table_ids",
15911            "stateTableIds",
15912            "upstream_fragment_ids",
15913            "upstreamFragmentIds",
15914            "maybe_vnode_count",
15915            "maybeVnodeCount",
15916            "nodes",
15917        ];
15918
15919        #[allow(clippy::enum_variant_names)]
15920        enum GeneratedField {
15921            FragmentId,
15922            FragmentTypeMask,
15923            DistributionType,
15924            Actors,
15925            StateTableIds,
15926            UpstreamFragmentIds,
15927            MaybeVnodeCount,
15928            Nodes,
15929        }
15930        impl<'de> serde::Deserialize<'de> for GeneratedField {
15931            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15932            where
15933                D: serde::Deserializer<'de>,
15934            {
15935                struct GeneratedVisitor;
15936
15937                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15938                    type Value = GeneratedField;
15939
15940                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15941                        write!(formatter, "expected one of: {:?}", &FIELDS)
15942                    }
15943
15944                    #[allow(unused_variables)]
15945                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15946                    where
15947                        E: serde::de::Error,
15948                    {
15949                        match value {
15950                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
15951                            "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
15952                            "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
15953                            "actors" => Ok(GeneratedField::Actors),
15954                            "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
15955                            "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
15956                            "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
15957                            "nodes" => Ok(GeneratedField::Nodes),
15958                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15959                        }
15960                    }
15961                }
15962                deserializer.deserialize_identifier(GeneratedVisitor)
15963            }
15964        }
15965        struct GeneratedVisitor;
15966        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15967            type Value = table_fragments::Fragment;
15968
15969            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15970                formatter.write_str("struct meta.TableFragments.Fragment")
15971            }
15972
15973            fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
15974                where
15975                    V: serde::de::MapAccess<'de>,
15976            {
15977                let mut fragment_id__ = None;
15978                let mut fragment_type_mask__ = None;
15979                let mut distribution_type__ = None;
15980                let mut actors__ = None;
15981                let mut state_table_ids__ = None;
15982                let mut upstream_fragment_ids__ = None;
15983                let mut maybe_vnode_count__ = None;
15984                let mut nodes__ = None;
15985                while let Some(k) = map_.next_key()? {
15986                    match k {
15987                        GeneratedField::FragmentId => {
15988                            if fragment_id__.is_some() {
15989                                return Err(serde::de::Error::duplicate_field("fragmentId"));
15990                            }
15991                            fragment_id__ = 
15992                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15993                            ;
15994                        }
15995                        GeneratedField::FragmentTypeMask => {
15996                            if fragment_type_mask__.is_some() {
15997                                return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
15998                            }
15999                            fragment_type_mask__ = 
16000                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16001                            ;
16002                        }
16003                        GeneratedField::DistributionType => {
16004                            if distribution_type__.is_some() {
16005                                return Err(serde::de::Error::duplicate_field("distributionType"));
16006                            }
16007                            distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
16008                        }
16009                        GeneratedField::Actors => {
16010                            if actors__.is_some() {
16011                                return Err(serde::de::Error::duplicate_field("actors"));
16012                            }
16013                            actors__ = Some(map_.next_value()?);
16014                        }
16015                        GeneratedField::StateTableIds => {
16016                            if state_table_ids__.is_some() {
16017                                return Err(serde::de::Error::duplicate_field("stateTableIds"));
16018                            }
16019                            state_table_ids__ = 
16020                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16021                                    .into_iter().map(|x| x.0).collect())
16022                            ;
16023                        }
16024                        GeneratedField::UpstreamFragmentIds => {
16025                            if upstream_fragment_ids__.is_some() {
16026                                return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
16027                            }
16028                            upstream_fragment_ids__ = 
16029                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16030                                    .into_iter().map(|x| x.0).collect())
16031                            ;
16032                        }
16033                        GeneratedField::MaybeVnodeCount => {
16034                            if maybe_vnode_count__.is_some() {
16035                                return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
16036                            }
16037                            maybe_vnode_count__ = 
16038                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16039                            ;
16040                        }
16041                        GeneratedField::Nodes => {
16042                            if nodes__.is_some() {
16043                                return Err(serde::de::Error::duplicate_field("nodes"));
16044                            }
16045                            nodes__ = map_.next_value()?;
16046                        }
16047                    }
16048                }
16049                Ok(table_fragments::Fragment {
16050                    fragment_id: fragment_id__.unwrap_or_default(),
16051                    fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
16052                    distribution_type: distribution_type__.unwrap_or_default(),
16053                    actors: actors__.unwrap_or_default(),
16054                    state_table_ids: state_table_ids__.unwrap_or_default(),
16055                    upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
16056                    maybe_vnode_count: maybe_vnode_count__,
16057                    nodes: nodes__,
16058                })
16059            }
16060        }
16061        deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
16062    }
16063}
16064impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
16065    #[allow(deprecated)]
16066    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16067    where
16068        S: serde::Serializer,
16069    {
16070        let variant = match self {
16071            Self::Unspecified => "UNSPECIFIED",
16072            Self::Single => "SINGLE",
16073            Self::Hash => "HASH",
16074        };
16075        serializer.serialize_str(variant)
16076    }
16077}
16078impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
16079    #[allow(deprecated)]
16080    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16081    where
16082        D: serde::Deserializer<'de>,
16083    {
16084        const FIELDS: &[&str] = &[
16085            "UNSPECIFIED",
16086            "SINGLE",
16087            "HASH",
16088        ];
16089
16090        struct GeneratedVisitor;
16091
16092        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16093            type Value = table_fragments::fragment::FragmentDistributionType;
16094
16095            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16096                write!(formatter, "expected one of: {:?}", &FIELDS)
16097            }
16098
16099            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16100            where
16101                E: serde::de::Error,
16102            {
16103                i32::try_from(v)
16104                    .ok()
16105                    .and_then(|x| x.try_into().ok())
16106                    .ok_or_else(|| {
16107                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16108                    })
16109            }
16110
16111            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16112            where
16113                E: serde::de::Error,
16114            {
16115                i32::try_from(v)
16116                    .ok()
16117                    .and_then(|x| x.try_into().ok())
16118                    .ok_or_else(|| {
16119                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16120                    })
16121            }
16122
16123            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16124            where
16125                E: serde::de::Error,
16126            {
16127                match value {
16128                    "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
16129                    "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
16130                    "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
16131                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16132                }
16133            }
16134        }
16135        deserializer.deserialize_any(GeneratedVisitor)
16136    }
16137}
16138impl serde::Serialize for table_fragments::State {
16139    #[allow(deprecated)]
16140    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16141    where
16142        S: serde::Serializer,
16143    {
16144        let variant = match self {
16145            Self::Unspecified => "UNSPECIFIED",
16146            Self::Initial => "INITIAL",
16147            Self::Creating => "CREATING",
16148            Self::Created => "CREATED",
16149        };
16150        serializer.serialize_str(variant)
16151    }
16152}
16153impl<'de> serde::Deserialize<'de> for table_fragments::State {
16154    #[allow(deprecated)]
16155    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16156    where
16157        D: serde::Deserializer<'de>,
16158    {
16159        const FIELDS: &[&str] = &[
16160            "UNSPECIFIED",
16161            "INITIAL",
16162            "CREATING",
16163            "CREATED",
16164        ];
16165
16166        struct GeneratedVisitor;
16167
16168        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16169            type Value = table_fragments::State;
16170
16171            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16172                write!(formatter, "expected one of: {:?}", &FIELDS)
16173            }
16174
16175            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16176            where
16177                E: serde::de::Error,
16178            {
16179                i32::try_from(v)
16180                    .ok()
16181                    .and_then(|x| x.try_into().ok())
16182                    .ok_or_else(|| {
16183                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16184                    })
16185            }
16186
16187            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16188            where
16189                E: serde::de::Error,
16190            {
16191                i32::try_from(v)
16192                    .ok()
16193                    .and_then(|x| x.try_into().ok())
16194                    .ok_or_else(|| {
16195                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16196                    })
16197            }
16198
16199            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16200            where
16201                E: serde::de::Error,
16202            {
16203                match value {
16204                    "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
16205                    "INITIAL" => Ok(table_fragments::State::Initial),
16206                    "CREATING" => Ok(table_fragments::State::Creating),
16207                    "CREATED" => Ok(table_fragments::State::Created),
16208                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16209                }
16210            }
16211        }
16212        deserializer.deserialize_any(GeneratedVisitor)
16213    }
16214}
16215impl serde::Serialize for TableParallelism {
16216    #[allow(deprecated)]
16217    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16218    where
16219        S: serde::Serializer,
16220    {
16221        use serde::ser::SerializeStruct;
16222        let mut len = 0;
16223        if self.parallelism.is_some() {
16224            len += 1;
16225        }
16226        let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
16227        if let Some(v) = self.parallelism.as_ref() {
16228            match v {
16229                table_parallelism::Parallelism::Fixed(v) => {
16230                    struct_ser.serialize_field("fixed", v)?;
16231                }
16232                table_parallelism::Parallelism::Auto(v) => {
16233                    struct_ser.serialize_field("auto", v)?;
16234                }
16235                table_parallelism::Parallelism::Custom(v) => {
16236                    struct_ser.serialize_field("custom", v)?;
16237                }
16238                table_parallelism::Parallelism::Adaptive(v) => {
16239                    struct_ser.serialize_field("adaptive", v)?;
16240                }
16241            }
16242        }
16243        struct_ser.end()
16244    }
16245}
16246impl<'de> serde::Deserialize<'de> for TableParallelism {
16247    #[allow(deprecated)]
16248    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16249    where
16250        D: serde::Deserializer<'de>,
16251    {
16252        const FIELDS: &[&str] = &[
16253            "fixed",
16254            "auto",
16255            "custom",
16256            "adaptive",
16257        ];
16258
16259        #[allow(clippy::enum_variant_names)]
16260        enum GeneratedField {
16261            Fixed,
16262            Auto,
16263            Custom,
16264            Adaptive,
16265        }
16266        impl<'de> serde::Deserialize<'de> for GeneratedField {
16267            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16268            where
16269                D: serde::Deserializer<'de>,
16270            {
16271                struct GeneratedVisitor;
16272
16273                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16274                    type Value = GeneratedField;
16275
16276                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16277                        write!(formatter, "expected one of: {:?}", &FIELDS)
16278                    }
16279
16280                    #[allow(unused_variables)]
16281                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16282                    where
16283                        E: serde::de::Error,
16284                    {
16285                        match value {
16286                            "fixed" => Ok(GeneratedField::Fixed),
16287                            "auto" => Ok(GeneratedField::Auto),
16288                            "custom" => Ok(GeneratedField::Custom),
16289                            "adaptive" => Ok(GeneratedField::Adaptive),
16290                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16291                        }
16292                    }
16293                }
16294                deserializer.deserialize_identifier(GeneratedVisitor)
16295            }
16296        }
16297        struct GeneratedVisitor;
16298        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16299            type Value = TableParallelism;
16300
16301            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16302                formatter.write_str("struct meta.TableParallelism")
16303            }
16304
16305            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
16306                where
16307                    V: serde::de::MapAccess<'de>,
16308            {
16309                let mut parallelism__ = None;
16310                while let Some(k) = map_.next_key()? {
16311                    match k {
16312                        GeneratedField::Fixed => {
16313                            if parallelism__.is_some() {
16314                                return Err(serde::de::Error::duplicate_field("fixed"));
16315                            }
16316                            parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
16317;
16318                        }
16319                        GeneratedField::Auto => {
16320                            if parallelism__.is_some() {
16321                                return Err(serde::de::Error::duplicate_field("auto"));
16322                            }
16323                            parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
16324;
16325                        }
16326                        GeneratedField::Custom => {
16327                            if parallelism__.is_some() {
16328                                return Err(serde::de::Error::duplicate_field("custom"));
16329                            }
16330                            parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
16331;
16332                        }
16333                        GeneratedField::Adaptive => {
16334                            if parallelism__.is_some() {
16335                                return Err(serde::de::Error::duplicate_field("adaptive"));
16336                            }
16337                            parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
16338;
16339                        }
16340                    }
16341                }
16342                Ok(TableParallelism {
16343                    parallelism: parallelism__,
16344                })
16345            }
16346        }
16347        deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
16348    }
16349}
16350impl serde::Serialize for table_parallelism::AdaptiveParallelism {
16351    #[allow(deprecated)]
16352    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16353    where
16354        S: serde::Serializer,
16355    {
16356        use serde::ser::SerializeStruct;
16357        let len = 0;
16358        let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
16359        struct_ser.end()
16360    }
16361}
16362impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
16363    #[allow(deprecated)]
16364    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16365    where
16366        D: serde::Deserializer<'de>,
16367    {
16368        const FIELDS: &[&str] = &[
16369        ];
16370
16371        #[allow(clippy::enum_variant_names)]
16372        enum GeneratedField {
16373        }
16374        impl<'de> serde::Deserialize<'de> for GeneratedField {
16375            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16376            where
16377                D: serde::Deserializer<'de>,
16378            {
16379                struct GeneratedVisitor;
16380
16381                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16382                    type Value = GeneratedField;
16383
16384                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16385                        write!(formatter, "expected one of: {:?}", &FIELDS)
16386                    }
16387
16388                    #[allow(unused_variables)]
16389                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16390                    where
16391                        E: serde::de::Error,
16392                    {
16393                            Err(serde::de::Error::unknown_field(value, FIELDS))
16394                    }
16395                }
16396                deserializer.deserialize_identifier(GeneratedVisitor)
16397            }
16398        }
16399        struct GeneratedVisitor;
16400        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16401            type Value = table_parallelism::AdaptiveParallelism;
16402
16403            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16404                formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
16405            }
16406
16407            fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
16408                where
16409                    V: serde::de::MapAccess<'de>,
16410            {
16411                while map_.next_key::<GeneratedField>()?.is_some() {
16412                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16413                }
16414                Ok(table_parallelism::AdaptiveParallelism {
16415                })
16416            }
16417        }
16418        deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
16419    }
16420}
16421impl serde::Serialize for table_parallelism::AutoParallelism {
16422    #[allow(deprecated)]
16423    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16424    where
16425        S: serde::Serializer,
16426    {
16427        use serde::ser::SerializeStruct;
16428        let len = 0;
16429        let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
16430        struct_ser.end()
16431    }
16432}
16433impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
16434    #[allow(deprecated)]
16435    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16436    where
16437        D: serde::Deserializer<'de>,
16438    {
16439        const FIELDS: &[&str] = &[
16440        ];
16441
16442        #[allow(clippy::enum_variant_names)]
16443        enum GeneratedField {
16444        }
16445        impl<'de> serde::Deserialize<'de> for GeneratedField {
16446            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16447            where
16448                D: serde::Deserializer<'de>,
16449            {
16450                struct GeneratedVisitor;
16451
16452                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16453                    type Value = GeneratedField;
16454
16455                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16456                        write!(formatter, "expected one of: {:?}", &FIELDS)
16457                    }
16458
16459                    #[allow(unused_variables)]
16460                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16461                    where
16462                        E: serde::de::Error,
16463                    {
16464                            Err(serde::de::Error::unknown_field(value, FIELDS))
16465                    }
16466                }
16467                deserializer.deserialize_identifier(GeneratedVisitor)
16468            }
16469        }
16470        struct GeneratedVisitor;
16471        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16472            type Value = table_parallelism::AutoParallelism;
16473
16474            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16475                formatter.write_str("struct meta.TableParallelism.AutoParallelism")
16476            }
16477
16478            fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
16479                where
16480                    V: serde::de::MapAccess<'de>,
16481            {
16482                while map_.next_key::<GeneratedField>()?.is_some() {
16483                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16484                }
16485                Ok(table_parallelism::AutoParallelism {
16486                })
16487            }
16488        }
16489        deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
16490    }
16491}
16492impl serde::Serialize for table_parallelism::CustomParallelism {
16493    #[allow(deprecated)]
16494    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16495    where
16496        S: serde::Serializer,
16497    {
16498        use serde::ser::SerializeStruct;
16499        let len = 0;
16500        let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
16501        struct_ser.end()
16502    }
16503}
16504impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
16505    #[allow(deprecated)]
16506    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16507    where
16508        D: serde::Deserializer<'de>,
16509    {
16510        const FIELDS: &[&str] = &[
16511        ];
16512
16513        #[allow(clippy::enum_variant_names)]
16514        enum GeneratedField {
16515        }
16516        impl<'de> serde::Deserialize<'de> for GeneratedField {
16517            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16518            where
16519                D: serde::Deserializer<'de>,
16520            {
16521                struct GeneratedVisitor;
16522
16523                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16524                    type Value = GeneratedField;
16525
16526                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16527                        write!(formatter, "expected one of: {:?}", &FIELDS)
16528                    }
16529
16530                    #[allow(unused_variables)]
16531                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16532                    where
16533                        E: serde::de::Error,
16534                    {
16535                            Err(serde::de::Error::unknown_field(value, FIELDS))
16536                    }
16537                }
16538                deserializer.deserialize_identifier(GeneratedVisitor)
16539            }
16540        }
16541        struct GeneratedVisitor;
16542        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16543            type Value = table_parallelism::CustomParallelism;
16544
16545            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16546                formatter.write_str("struct meta.TableParallelism.CustomParallelism")
16547            }
16548
16549            fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
16550                where
16551                    V: serde::de::MapAccess<'de>,
16552            {
16553                while map_.next_key::<GeneratedField>()?.is_some() {
16554                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16555                }
16556                Ok(table_parallelism::CustomParallelism {
16557                })
16558            }
16559        }
16560        deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
16561    }
16562}
16563impl serde::Serialize for table_parallelism::FixedParallelism {
16564    #[allow(deprecated)]
16565    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16566    where
16567        S: serde::Serializer,
16568    {
16569        use serde::ser::SerializeStruct;
16570        let mut len = 0;
16571        if self.parallelism != 0 {
16572            len += 1;
16573        }
16574        let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
16575        if self.parallelism != 0 {
16576            struct_ser.serialize_field("parallelism", &self.parallelism)?;
16577        }
16578        struct_ser.end()
16579    }
16580}
16581impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
16582    #[allow(deprecated)]
16583    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16584    where
16585        D: serde::Deserializer<'de>,
16586    {
16587        const FIELDS: &[&str] = &[
16588            "parallelism",
16589        ];
16590
16591        #[allow(clippy::enum_variant_names)]
16592        enum GeneratedField {
16593            Parallelism,
16594        }
16595        impl<'de> serde::Deserialize<'de> for GeneratedField {
16596            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16597            where
16598                D: serde::Deserializer<'de>,
16599            {
16600                struct GeneratedVisitor;
16601
16602                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16603                    type Value = GeneratedField;
16604
16605                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16606                        write!(formatter, "expected one of: {:?}", &FIELDS)
16607                    }
16608
16609                    #[allow(unused_variables)]
16610                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16611                    where
16612                        E: serde::de::Error,
16613                    {
16614                        match value {
16615                            "parallelism" => Ok(GeneratedField::Parallelism),
16616                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16617                        }
16618                    }
16619                }
16620                deserializer.deserialize_identifier(GeneratedVisitor)
16621            }
16622        }
16623        struct GeneratedVisitor;
16624        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16625            type Value = table_parallelism::FixedParallelism;
16626
16627            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16628                formatter.write_str("struct meta.TableParallelism.FixedParallelism")
16629            }
16630
16631            fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
16632                where
16633                    V: serde::de::MapAccess<'de>,
16634            {
16635                let mut parallelism__ = None;
16636                while let Some(k) = map_.next_key()? {
16637                    match k {
16638                        GeneratedField::Parallelism => {
16639                            if parallelism__.is_some() {
16640                                return Err(serde::de::Error::duplicate_field("parallelism"));
16641                            }
16642                            parallelism__ = 
16643                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16644                            ;
16645                        }
16646                    }
16647                }
16648                Ok(table_parallelism::FixedParallelism {
16649                    parallelism: parallelism__.unwrap_or_default(),
16650                })
16651            }
16652        }
16653        deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
16654    }
16655}
16656impl serde::Serialize for TelemetryInfoResponse {
16657    #[allow(deprecated)]
16658    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16659    where
16660        S: serde::Serializer,
16661    {
16662        use serde::ser::SerializeStruct;
16663        let mut len = 0;
16664        if self.tracking_id.is_some() {
16665            len += 1;
16666        }
16667        let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
16668        if let Some(v) = self.tracking_id.as_ref() {
16669            struct_ser.serialize_field("trackingId", v)?;
16670        }
16671        struct_ser.end()
16672    }
16673}
16674impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
16675    #[allow(deprecated)]
16676    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16677    where
16678        D: serde::Deserializer<'de>,
16679    {
16680        const FIELDS: &[&str] = &[
16681            "tracking_id",
16682            "trackingId",
16683        ];
16684
16685        #[allow(clippy::enum_variant_names)]
16686        enum GeneratedField {
16687            TrackingId,
16688        }
16689        impl<'de> serde::Deserialize<'de> for GeneratedField {
16690            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16691            where
16692                D: serde::Deserializer<'de>,
16693            {
16694                struct GeneratedVisitor;
16695
16696                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16697                    type Value = GeneratedField;
16698
16699                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16700                        write!(formatter, "expected one of: {:?}", &FIELDS)
16701                    }
16702
16703                    #[allow(unused_variables)]
16704                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16705                    where
16706                        E: serde::de::Error,
16707                    {
16708                        match value {
16709                            "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
16710                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16711                        }
16712                    }
16713                }
16714                deserializer.deserialize_identifier(GeneratedVisitor)
16715            }
16716        }
16717        struct GeneratedVisitor;
16718        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16719            type Value = TelemetryInfoResponse;
16720
16721            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16722                formatter.write_str("struct meta.TelemetryInfoResponse")
16723            }
16724
16725            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
16726                where
16727                    V: serde::de::MapAccess<'de>,
16728            {
16729                let mut tracking_id__ = None;
16730                while let Some(k) = map_.next_key()? {
16731                    match k {
16732                        GeneratedField::TrackingId => {
16733                            if tracking_id__.is_some() {
16734                                return Err(serde::de::Error::duplicate_field("trackingId"));
16735                            }
16736                            tracking_id__ = map_.next_value()?;
16737                        }
16738                    }
16739                }
16740                Ok(TelemetryInfoResponse {
16741                    tracking_id: tracking_id__,
16742                })
16743            }
16744        }
16745        deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
16746    }
16747}
16748impl serde::Serialize for ThrottleTarget {
16749    #[allow(deprecated)]
16750    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16751    where
16752        S: serde::Serializer,
16753    {
16754        let variant = match self {
16755            Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
16756            Self::Source => "SOURCE",
16757            Self::Mv => "MV",
16758            Self::TableWithSource => "TABLE_WITH_SOURCE",
16759            Self::CdcTable => "CDC_TABLE",
16760            Self::TableDml => "TABLE_DML",
16761            Self::Sink => "SINK",
16762            Self::Fragment => "FRAGMENT",
16763        };
16764        serializer.serialize_str(variant)
16765    }
16766}
16767impl<'de> serde::Deserialize<'de> for ThrottleTarget {
16768    #[allow(deprecated)]
16769    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16770    where
16771        D: serde::Deserializer<'de>,
16772    {
16773        const FIELDS: &[&str] = &[
16774            "THROTTLE_TARGET_UNSPECIFIED",
16775            "SOURCE",
16776            "MV",
16777            "TABLE_WITH_SOURCE",
16778            "CDC_TABLE",
16779            "TABLE_DML",
16780            "SINK",
16781            "FRAGMENT",
16782        ];
16783
16784        struct GeneratedVisitor;
16785
16786        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16787            type Value = ThrottleTarget;
16788
16789            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16790                write!(formatter, "expected one of: {:?}", &FIELDS)
16791            }
16792
16793            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16794            where
16795                E: serde::de::Error,
16796            {
16797                i32::try_from(v)
16798                    .ok()
16799                    .and_then(|x| x.try_into().ok())
16800                    .ok_or_else(|| {
16801                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16802                    })
16803            }
16804
16805            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16806            where
16807                E: serde::de::Error,
16808            {
16809                i32::try_from(v)
16810                    .ok()
16811                    .and_then(|x| x.try_into().ok())
16812                    .ok_or_else(|| {
16813                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16814                    })
16815            }
16816
16817            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16818            where
16819                E: serde::de::Error,
16820            {
16821                match value {
16822                    "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
16823                    "SOURCE" => Ok(ThrottleTarget::Source),
16824                    "MV" => Ok(ThrottleTarget::Mv),
16825                    "TABLE_WITH_SOURCE" => Ok(ThrottleTarget::TableWithSource),
16826                    "CDC_TABLE" => Ok(ThrottleTarget::CdcTable),
16827                    "TABLE_DML" => Ok(ThrottleTarget::TableDml),
16828                    "SINK" => Ok(ThrottleTarget::Sink),
16829                    "FRAGMENT" => Ok(ThrottleTarget::Fragment),
16830                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16831                }
16832            }
16833        }
16834        deserializer.deserialize_any(GeneratedVisitor)
16835    }
16836}
16837impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
16838    #[allow(deprecated)]
16839    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16840    where
16841        S: serde::Serializer,
16842    {
16843        use serde::ser::SerializeStruct;
16844        let mut len = 0;
16845        if self.id != 0 {
16846            len += 1;
16847        }
16848        if !self.node_label.is_empty() {
16849            len += 1;
16850        }
16851        let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
16852        if self.id != 0 {
16853            struct_ser.serialize_field("id", &self.id)?;
16854        }
16855        if !self.node_label.is_empty() {
16856            struct_ser.serialize_field("nodeLabel", &self.node_label)?;
16857        }
16858        struct_ser.end()
16859    }
16860}
16861impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
16862    #[allow(deprecated)]
16863    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16864    where
16865        D: serde::Deserializer<'de>,
16866    {
16867        const FIELDS: &[&str] = &[
16868            "id",
16869            "node_label",
16870            "nodeLabel",
16871        ];
16872
16873        #[allow(clippy::enum_variant_names)]
16874        enum GeneratedField {
16875            Id,
16876            NodeLabel,
16877        }
16878        impl<'de> serde::Deserialize<'de> for GeneratedField {
16879            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16880            where
16881                D: serde::Deserializer<'de>,
16882            {
16883                struct GeneratedVisitor;
16884
16885                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16886                    type Value = GeneratedField;
16887
16888                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16889                        write!(formatter, "expected one of: {:?}", &FIELDS)
16890                    }
16891
16892                    #[allow(unused_variables)]
16893                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16894                    where
16895                        E: serde::de::Error,
16896                    {
16897                        match value {
16898                            "id" => Ok(GeneratedField::Id),
16899                            "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
16900                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16901                        }
16902                    }
16903                }
16904                deserializer.deserialize_identifier(GeneratedVisitor)
16905            }
16906        }
16907        struct GeneratedVisitor;
16908        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16909            type Value = UpdateStreamingJobNodeLabelsRequest;
16910
16911            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16912                formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
16913            }
16914
16915            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
16916                where
16917                    V: serde::de::MapAccess<'de>,
16918            {
16919                let mut id__ = None;
16920                let mut node_label__ = None;
16921                while let Some(k) = map_.next_key()? {
16922                    match k {
16923                        GeneratedField::Id => {
16924                            if id__.is_some() {
16925                                return Err(serde::de::Error::duplicate_field("id"));
16926                            }
16927                            id__ = 
16928                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16929                            ;
16930                        }
16931                        GeneratedField::NodeLabel => {
16932                            if node_label__.is_some() {
16933                                return Err(serde::de::Error::duplicate_field("nodeLabel"));
16934                            }
16935                            node_label__ = Some(map_.next_value()?);
16936                        }
16937                    }
16938                }
16939                Ok(UpdateStreamingJobNodeLabelsRequest {
16940                    id: id__.unwrap_or_default(),
16941                    node_label: node_label__.unwrap_or_default(),
16942                })
16943            }
16944        }
16945        deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
16946    }
16947}
16948impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
16949    #[allow(deprecated)]
16950    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16951    where
16952        S: serde::Serializer,
16953    {
16954        use serde::ser::SerializeStruct;
16955        let len = 0;
16956        let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
16957        struct_ser.end()
16958    }
16959}
16960impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
16961    #[allow(deprecated)]
16962    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16963    where
16964        D: serde::Deserializer<'de>,
16965    {
16966        const FIELDS: &[&str] = &[
16967        ];
16968
16969        #[allow(clippy::enum_variant_names)]
16970        enum GeneratedField {
16971        }
16972        impl<'de> serde::Deserialize<'de> for GeneratedField {
16973            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16974            where
16975                D: serde::Deserializer<'de>,
16976            {
16977                struct GeneratedVisitor;
16978
16979                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16980                    type Value = GeneratedField;
16981
16982                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16983                        write!(formatter, "expected one of: {:?}", &FIELDS)
16984                    }
16985
16986                    #[allow(unused_variables)]
16987                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16988                    where
16989                        E: serde::de::Error,
16990                    {
16991                            Err(serde::de::Error::unknown_field(value, FIELDS))
16992                    }
16993                }
16994                deserializer.deserialize_identifier(GeneratedVisitor)
16995            }
16996        }
16997        struct GeneratedVisitor;
16998        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16999            type Value = UpdateStreamingJobNodeLabelsResponse;
17000
17001            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17002                formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
17003            }
17004
17005            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
17006                where
17007                    V: serde::de::MapAccess<'de>,
17008            {
17009                while map_.next_key::<GeneratedField>()?.is_some() {
17010                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17011                }
17012                Ok(UpdateStreamingJobNodeLabelsResponse {
17013                })
17014            }
17015        }
17016        deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
17017    }
17018}
17019impl serde::Serialize for UpdateWorkerNodeSchedulabilityRequest {
17020    #[allow(deprecated)]
17021    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17022    where
17023        S: serde::Serializer,
17024    {
17025        use serde::ser::SerializeStruct;
17026        let mut len = 0;
17027        if !self.worker_ids.is_empty() {
17028            len += 1;
17029        }
17030        if self.schedulability != 0 {
17031            len += 1;
17032        }
17033        let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", len)?;
17034        if !self.worker_ids.is_empty() {
17035            struct_ser.serialize_field("workerIds", &self.worker_ids)?;
17036        }
17037        if self.schedulability != 0 {
17038            let v = update_worker_node_schedulability_request::Schedulability::try_from(self.schedulability)
17039                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.schedulability)))?;
17040            struct_ser.serialize_field("schedulability", &v)?;
17041        }
17042        struct_ser.end()
17043    }
17044}
17045impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityRequest {
17046    #[allow(deprecated)]
17047    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17048    where
17049        D: serde::Deserializer<'de>,
17050    {
17051        const FIELDS: &[&str] = &[
17052            "worker_ids",
17053            "workerIds",
17054            "schedulability",
17055        ];
17056
17057        #[allow(clippy::enum_variant_names)]
17058        enum GeneratedField {
17059            WorkerIds,
17060            Schedulability,
17061        }
17062        impl<'de> serde::Deserialize<'de> for GeneratedField {
17063            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17064            where
17065                D: serde::Deserializer<'de>,
17066            {
17067                struct GeneratedVisitor;
17068
17069                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17070                    type Value = GeneratedField;
17071
17072                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17073                        write!(formatter, "expected one of: {:?}", &FIELDS)
17074                    }
17075
17076                    #[allow(unused_variables)]
17077                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17078                    where
17079                        E: serde::de::Error,
17080                    {
17081                        match value {
17082                            "workerIds" | "worker_ids" => Ok(GeneratedField::WorkerIds),
17083                            "schedulability" => Ok(GeneratedField::Schedulability),
17084                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17085                        }
17086                    }
17087                }
17088                deserializer.deserialize_identifier(GeneratedVisitor)
17089            }
17090        }
17091        struct GeneratedVisitor;
17092        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17093            type Value = UpdateWorkerNodeSchedulabilityRequest;
17094
17095            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17096                formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityRequest")
17097            }
17098
17099            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityRequest, V::Error>
17100                where
17101                    V: serde::de::MapAccess<'de>,
17102            {
17103                let mut worker_ids__ = None;
17104                let mut schedulability__ = None;
17105                while let Some(k) = map_.next_key()? {
17106                    match k {
17107                        GeneratedField::WorkerIds => {
17108                            if worker_ids__.is_some() {
17109                                return Err(serde::de::Error::duplicate_field("workerIds"));
17110                            }
17111                            worker_ids__ = 
17112                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17113                                    .into_iter().map(|x| x.0).collect())
17114                            ;
17115                        }
17116                        GeneratedField::Schedulability => {
17117                            if schedulability__.is_some() {
17118                                return Err(serde::de::Error::duplicate_field("schedulability"));
17119                            }
17120                            schedulability__ = Some(map_.next_value::<update_worker_node_schedulability_request::Schedulability>()? as i32);
17121                        }
17122                    }
17123                }
17124                Ok(UpdateWorkerNodeSchedulabilityRequest {
17125                    worker_ids: worker_ids__.unwrap_or_default(),
17126                    schedulability: schedulability__.unwrap_or_default(),
17127                })
17128            }
17129        }
17130        deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", FIELDS, GeneratedVisitor)
17131    }
17132}
17133impl serde::Serialize for update_worker_node_schedulability_request::Schedulability {
17134    #[allow(deprecated)]
17135    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17136    where
17137        S: serde::Serializer,
17138    {
17139        let variant = match self {
17140            Self::Unspecified => "UNSPECIFIED",
17141            Self::Schedulable => "SCHEDULABLE",
17142            Self::Unschedulable => "UNSCHEDULABLE",
17143        };
17144        serializer.serialize_str(variant)
17145    }
17146}
17147impl<'de> serde::Deserialize<'de> for update_worker_node_schedulability_request::Schedulability {
17148    #[allow(deprecated)]
17149    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17150    where
17151        D: serde::Deserializer<'de>,
17152    {
17153        const FIELDS: &[&str] = &[
17154            "UNSPECIFIED",
17155            "SCHEDULABLE",
17156            "UNSCHEDULABLE",
17157        ];
17158
17159        struct GeneratedVisitor;
17160
17161        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17162            type Value = update_worker_node_schedulability_request::Schedulability;
17163
17164            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17165                write!(formatter, "expected one of: {:?}", &FIELDS)
17166            }
17167
17168            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17169            where
17170                E: serde::de::Error,
17171            {
17172                i32::try_from(v)
17173                    .ok()
17174                    .and_then(|x| x.try_into().ok())
17175                    .ok_or_else(|| {
17176                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17177                    })
17178            }
17179
17180            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17181            where
17182                E: serde::de::Error,
17183            {
17184                i32::try_from(v)
17185                    .ok()
17186                    .and_then(|x| x.try_into().ok())
17187                    .ok_or_else(|| {
17188                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17189                    })
17190            }
17191
17192            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17193            where
17194                E: serde::de::Error,
17195            {
17196                match value {
17197                    "UNSPECIFIED" => Ok(update_worker_node_schedulability_request::Schedulability::Unspecified),
17198                    "SCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Schedulable),
17199                    "UNSCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Unschedulable),
17200                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17201                }
17202            }
17203        }
17204        deserializer.deserialize_any(GeneratedVisitor)
17205    }
17206}
17207impl serde::Serialize for UpdateWorkerNodeSchedulabilityResponse {
17208    #[allow(deprecated)]
17209    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17210    where
17211        S: serde::Serializer,
17212    {
17213        use serde::ser::SerializeStruct;
17214        let mut len = 0;
17215        if self.status.is_some() {
17216            len += 1;
17217        }
17218        let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", len)?;
17219        if let Some(v) = self.status.as_ref() {
17220            struct_ser.serialize_field("status", v)?;
17221        }
17222        struct_ser.end()
17223    }
17224}
17225impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityResponse {
17226    #[allow(deprecated)]
17227    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17228    where
17229        D: serde::Deserializer<'de>,
17230    {
17231        const FIELDS: &[&str] = &[
17232            "status",
17233        ];
17234
17235        #[allow(clippy::enum_variant_names)]
17236        enum GeneratedField {
17237            Status,
17238        }
17239        impl<'de> serde::Deserialize<'de> for GeneratedField {
17240            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17241            where
17242                D: serde::Deserializer<'de>,
17243            {
17244                struct GeneratedVisitor;
17245
17246                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17247                    type Value = GeneratedField;
17248
17249                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17250                        write!(formatter, "expected one of: {:?}", &FIELDS)
17251                    }
17252
17253                    #[allow(unused_variables)]
17254                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17255                    where
17256                        E: serde::de::Error,
17257                    {
17258                        match value {
17259                            "status" => Ok(GeneratedField::Status),
17260                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17261                        }
17262                    }
17263                }
17264                deserializer.deserialize_identifier(GeneratedVisitor)
17265            }
17266        }
17267        struct GeneratedVisitor;
17268        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17269            type Value = UpdateWorkerNodeSchedulabilityResponse;
17270
17271            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17272                formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityResponse")
17273            }
17274
17275            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityResponse, V::Error>
17276                where
17277                    V: serde::de::MapAccess<'de>,
17278            {
17279                let mut status__ = None;
17280                while let Some(k) = map_.next_key()? {
17281                    match k {
17282                        GeneratedField::Status => {
17283                            if status__.is_some() {
17284                                return Err(serde::de::Error::duplicate_field("status"));
17285                            }
17286                            status__ = map_.next_value()?;
17287                        }
17288                    }
17289                }
17290                Ok(UpdateWorkerNodeSchedulabilityResponse {
17291                    status: status__,
17292                })
17293            }
17294        }
17295        deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", FIELDS, GeneratedVisitor)
17296    }
17297}
17298impl serde::Serialize for WorkerReschedule {
17299    #[allow(deprecated)]
17300    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17301    where
17302        S: serde::Serializer,
17303    {
17304        use serde::ser::SerializeStruct;
17305        let mut len = 0;
17306        if !self.worker_actor_diff.is_empty() {
17307            len += 1;
17308        }
17309        let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
17310        if !self.worker_actor_diff.is_empty() {
17311            struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
17312        }
17313        struct_ser.end()
17314    }
17315}
17316impl<'de> serde::Deserialize<'de> for WorkerReschedule {
17317    #[allow(deprecated)]
17318    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17319    where
17320        D: serde::Deserializer<'de>,
17321    {
17322        const FIELDS: &[&str] = &[
17323            "worker_actor_diff",
17324            "workerActorDiff",
17325        ];
17326
17327        #[allow(clippy::enum_variant_names)]
17328        enum GeneratedField {
17329            WorkerActorDiff,
17330        }
17331        impl<'de> serde::Deserialize<'de> for GeneratedField {
17332            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17333            where
17334                D: serde::Deserializer<'de>,
17335            {
17336                struct GeneratedVisitor;
17337
17338                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17339                    type Value = GeneratedField;
17340
17341                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17342                        write!(formatter, "expected one of: {:?}", &FIELDS)
17343                    }
17344
17345                    #[allow(unused_variables)]
17346                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17347                    where
17348                        E: serde::de::Error,
17349                    {
17350                        match value {
17351                            "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
17352                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17353                        }
17354                    }
17355                }
17356                deserializer.deserialize_identifier(GeneratedVisitor)
17357            }
17358        }
17359        struct GeneratedVisitor;
17360        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17361            type Value = WorkerReschedule;
17362
17363            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17364                formatter.write_str("struct meta.WorkerReschedule")
17365            }
17366
17367            fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
17368                where
17369                    V: serde::de::MapAccess<'de>,
17370            {
17371                let mut worker_actor_diff__ = None;
17372                while let Some(k) = map_.next_key()? {
17373                    match k {
17374                        GeneratedField::WorkerActorDiff => {
17375                            if worker_actor_diff__.is_some() {
17376                                return Err(serde::de::Error::duplicate_field("workerActorDiff"));
17377                            }
17378                            worker_actor_diff__ = Some(
17379                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
17380                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
17381                            );
17382                        }
17383                    }
17384                }
17385                Ok(WorkerReschedule {
17386                    worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
17387                })
17388            }
17389        }
17390        deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
17391    }
17392}