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        if self.extra_options.is_some() {
1139            len += 1;
1140        }
1141        let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest", len)?;
1142        if self.object_id != 0 {
1143            struct_ser.serialize_field("objectId", &self.object_id)?;
1144        }
1145        if !self.changed_props.is_empty() {
1146            struct_ser.serialize_field("changedProps", &self.changed_props)?;
1147        }
1148        if !self.changed_secret_refs.is_empty() {
1149            struct_ser.serialize_field("changedSecretRefs", &self.changed_secret_refs)?;
1150        }
1151        if let Some(v) = self.connector_conn_ref.as_ref() {
1152            struct_ser.serialize_field("connectorConnRef", v)?;
1153        }
1154        if self.object_type != 0 {
1155            let v = alter_connector_props_request::AlterConnectorPropsObject::try_from(self.object_type)
1156                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.object_type)))?;
1157            struct_ser.serialize_field("objectType", &v)?;
1158        }
1159        if let Some(v) = self.extra_options.as_ref() {
1160            match v {
1161                alter_connector_props_request::ExtraOptions::AlterIcebergTableIds(v) => {
1162                    struct_ser.serialize_field("alterIcebergTableIds", v)?;
1163                }
1164            }
1165        }
1166        struct_ser.end()
1167    }
1168}
1169impl<'de> serde::Deserialize<'de> for AlterConnectorPropsRequest {
1170    #[allow(deprecated)]
1171    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1172    where
1173        D: serde::Deserializer<'de>,
1174    {
1175        const FIELDS: &[&str] = &[
1176            "object_id",
1177            "objectId",
1178            "changed_props",
1179            "changedProps",
1180            "changed_secret_refs",
1181            "changedSecretRefs",
1182            "connector_conn_ref",
1183            "connectorConnRef",
1184            "object_type",
1185            "objectType",
1186            "alter_iceberg_table_ids",
1187            "alterIcebergTableIds",
1188        ];
1189
1190        #[allow(clippy::enum_variant_names)]
1191        enum GeneratedField {
1192            ObjectId,
1193            ChangedProps,
1194            ChangedSecretRefs,
1195            ConnectorConnRef,
1196            ObjectType,
1197            AlterIcebergTableIds,
1198        }
1199        impl<'de> serde::Deserialize<'de> for GeneratedField {
1200            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1201            where
1202                D: serde::Deserializer<'de>,
1203            {
1204                struct GeneratedVisitor;
1205
1206                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1207                    type Value = GeneratedField;
1208
1209                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1210                        write!(formatter, "expected one of: {:?}", &FIELDS)
1211                    }
1212
1213                    #[allow(unused_variables)]
1214                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1215                    where
1216                        E: serde::de::Error,
1217                    {
1218                        match value {
1219                            "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
1220                            "changedProps" | "changed_props" => Ok(GeneratedField::ChangedProps),
1221                            "changedSecretRefs" | "changed_secret_refs" => Ok(GeneratedField::ChangedSecretRefs),
1222                            "connectorConnRef" | "connector_conn_ref" => Ok(GeneratedField::ConnectorConnRef),
1223                            "objectType" | "object_type" => Ok(GeneratedField::ObjectType),
1224                            "alterIcebergTableIds" | "alter_iceberg_table_ids" => Ok(GeneratedField::AlterIcebergTableIds),
1225                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1226                        }
1227                    }
1228                }
1229                deserializer.deserialize_identifier(GeneratedVisitor)
1230            }
1231        }
1232        struct GeneratedVisitor;
1233        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1234            type Value = AlterConnectorPropsRequest;
1235
1236            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1237                formatter.write_str("struct meta.AlterConnectorPropsRequest")
1238            }
1239
1240            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsRequest, V::Error>
1241                where
1242                    V: serde::de::MapAccess<'de>,
1243            {
1244                let mut object_id__ = None;
1245                let mut changed_props__ = None;
1246                let mut changed_secret_refs__ = None;
1247                let mut connector_conn_ref__ = None;
1248                let mut object_type__ = None;
1249                let mut extra_options__ = None;
1250                while let Some(k) = map_.next_key()? {
1251                    match k {
1252                        GeneratedField::ObjectId => {
1253                            if object_id__.is_some() {
1254                                return Err(serde::de::Error::duplicate_field("objectId"));
1255                            }
1256                            object_id__ = 
1257                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1258                            ;
1259                        }
1260                        GeneratedField::ChangedProps => {
1261                            if changed_props__.is_some() {
1262                                return Err(serde::de::Error::duplicate_field("changedProps"));
1263                            }
1264                            changed_props__ = Some(
1265                                map_.next_value::<std::collections::HashMap<_, _>>()?
1266                            );
1267                        }
1268                        GeneratedField::ChangedSecretRefs => {
1269                            if changed_secret_refs__.is_some() {
1270                                return Err(serde::de::Error::duplicate_field("changedSecretRefs"));
1271                            }
1272                            changed_secret_refs__ = Some(
1273                                map_.next_value::<std::collections::HashMap<_, _>>()?
1274                            );
1275                        }
1276                        GeneratedField::ConnectorConnRef => {
1277                            if connector_conn_ref__.is_some() {
1278                                return Err(serde::de::Error::duplicate_field("connectorConnRef"));
1279                            }
1280                            connector_conn_ref__ = 
1281                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1282                            ;
1283                        }
1284                        GeneratedField::ObjectType => {
1285                            if object_type__.is_some() {
1286                                return Err(serde::de::Error::duplicate_field("objectType"));
1287                            }
1288                            object_type__ = Some(map_.next_value::<alter_connector_props_request::AlterConnectorPropsObject>()? as i32);
1289                        }
1290                        GeneratedField::AlterIcebergTableIds => {
1291                            if extra_options__.is_some() {
1292                                return Err(serde::de::Error::duplicate_field("alterIcebergTableIds"));
1293                            }
1294                            extra_options__ = map_.next_value::<::std::option::Option<_>>()?.map(alter_connector_props_request::ExtraOptions::AlterIcebergTableIds)
1295;
1296                        }
1297                    }
1298                }
1299                Ok(AlterConnectorPropsRequest {
1300                    object_id: object_id__.unwrap_or_default(),
1301                    changed_props: changed_props__.unwrap_or_default(),
1302                    changed_secret_refs: changed_secret_refs__.unwrap_or_default(),
1303                    connector_conn_ref: connector_conn_ref__,
1304                    object_type: object_type__.unwrap_or_default(),
1305                    extra_options: extra_options__,
1306                })
1307            }
1308        }
1309        deserializer.deserialize_struct("meta.AlterConnectorPropsRequest", FIELDS, GeneratedVisitor)
1310    }
1311}
1312impl serde::Serialize for alter_connector_props_request::AlterConnectorPropsObject {
1313    #[allow(deprecated)]
1314    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1315    where
1316        S: serde::Serializer,
1317    {
1318        let variant = match self {
1319            Self::Unspecified => "UNSPECIFIED",
1320            Self::Source => "SOURCE",
1321            Self::Sink => "SINK",
1322            Self::Connection => "CONNECTION",
1323            Self::IcebergTable => "ICEBERG_TABLE",
1324        };
1325        serializer.serialize_str(variant)
1326    }
1327}
1328impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterConnectorPropsObject {
1329    #[allow(deprecated)]
1330    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1331    where
1332        D: serde::Deserializer<'de>,
1333    {
1334        const FIELDS: &[&str] = &[
1335            "UNSPECIFIED",
1336            "SOURCE",
1337            "SINK",
1338            "CONNECTION",
1339            "ICEBERG_TABLE",
1340        ];
1341
1342        struct GeneratedVisitor;
1343
1344        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1345            type Value = alter_connector_props_request::AlterConnectorPropsObject;
1346
1347            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1348                write!(formatter, "expected one of: {:?}", &FIELDS)
1349            }
1350
1351            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1352            where
1353                E: serde::de::Error,
1354            {
1355                i32::try_from(v)
1356                    .ok()
1357                    .and_then(|x| x.try_into().ok())
1358                    .ok_or_else(|| {
1359                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1360                    })
1361            }
1362
1363            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1364            where
1365                E: serde::de::Error,
1366            {
1367                i32::try_from(v)
1368                    .ok()
1369                    .and_then(|x| x.try_into().ok())
1370                    .ok_or_else(|| {
1371                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1372                    })
1373            }
1374
1375            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1376            where
1377                E: serde::de::Error,
1378            {
1379                match value {
1380                    "UNSPECIFIED" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Unspecified),
1381                    "SOURCE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Source),
1382                    "SINK" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Sink),
1383                    "CONNECTION" => Ok(alter_connector_props_request::AlterConnectorPropsObject::Connection),
1384                    "ICEBERG_TABLE" => Ok(alter_connector_props_request::AlterConnectorPropsObject::IcebergTable),
1385                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1386                }
1387            }
1388        }
1389        deserializer.deserialize_any(GeneratedVisitor)
1390    }
1391}
1392impl serde::Serialize for alter_connector_props_request::AlterIcebergTableIds {
1393    #[allow(deprecated)]
1394    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1395    where
1396        S: serde::Serializer,
1397    {
1398        use serde::ser::SerializeStruct;
1399        let mut len = 0;
1400        if self.source_id != 0 {
1401            len += 1;
1402        }
1403        if self.sink_id != 0 {
1404            len += 1;
1405        }
1406        let mut struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsRequest.AlterIcebergTableIds", len)?;
1407        if self.source_id != 0 {
1408            struct_ser.serialize_field("sourceId", &self.source_id)?;
1409        }
1410        if self.sink_id != 0 {
1411            struct_ser.serialize_field("sinkId", &self.sink_id)?;
1412        }
1413        struct_ser.end()
1414    }
1415}
1416impl<'de> serde::Deserialize<'de> for alter_connector_props_request::AlterIcebergTableIds {
1417    #[allow(deprecated)]
1418    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1419    where
1420        D: serde::Deserializer<'de>,
1421    {
1422        const FIELDS: &[&str] = &[
1423            "source_id",
1424            "sourceId",
1425            "sink_id",
1426            "sinkId",
1427        ];
1428
1429        #[allow(clippy::enum_variant_names)]
1430        enum GeneratedField {
1431            SourceId,
1432            SinkId,
1433        }
1434        impl<'de> serde::Deserialize<'de> for GeneratedField {
1435            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1436            where
1437                D: serde::Deserializer<'de>,
1438            {
1439                struct GeneratedVisitor;
1440
1441                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1442                    type Value = GeneratedField;
1443
1444                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1445                        write!(formatter, "expected one of: {:?}", &FIELDS)
1446                    }
1447
1448                    #[allow(unused_variables)]
1449                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1450                    where
1451                        E: serde::de::Error,
1452                    {
1453                        match value {
1454                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1455                            "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
1456                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1457                        }
1458                    }
1459                }
1460                deserializer.deserialize_identifier(GeneratedVisitor)
1461            }
1462        }
1463        struct GeneratedVisitor;
1464        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1465            type Value = alter_connector_props_request::AlterIcebergTableIds;
1466
1467            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1468                formatter.write_str("struct meta.AlterConnectorPropsRequest.AlterIcebergTableIds")
1469            }
1470
1471            fn visit_map<V>(self, mut map_: V) -> std::result::Result<alter_connector_props_request::AlterIcebergTableIds, V::Error>
1472                where
1473                    V: serde::de::MapAccess<'de>,
1474            {
1475                let mut source_id__ = None;
1476                let mut sink_id__ = None;
1477                while let Some(k) = map_.next_key()? {
1478                    match k {
1479                        GeneratedField::SourceId => {
1480                            if source_id__.is_some() {
1481                                return Err(serde::de::Error::duplicate_field("sourceId"));
1482                            }
1483                            source_id__ = 
1484                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1485                            ;
1486                        }
1487                        GeneratedField::SinkId => {
1488                            if sink_id__.is_some() {
1489                                return Err(serde::de::Error::duplicate_field("sinkId"));
1490                            }
1491                            sink_id__ = 
1492                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1493                            ;
1494                        }
1495                    }
1496                }
1497                Ok(alter_connector_props_request::AlterIcebergTableIds {
1498                    source_id: source_id__.unwrap_or_default(),
1499                    sink_id: sink_id__.unwrap_or_default(),
1500                })
1501            }
1502        }
1503        deserializer.deserialize_struct("meta.AlterConnectorPropsRequest.AlterIcebergTableIds", FIELDS, GeneratedVisitor)
1504    }
1505}
1506impl serde::Serialize for AlterConnectorPropsResponse {
1507    #[allow(deprecated)]
1508    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1509    where
1510        S: serde::Serializer,
1511    {
1512        use serde::ser::SerializeStruct;
1513        let len = 0;
1514        let struct_ser = serializer.serialize_struct("meta.AlterConnectorPropsResponse", len)?;
1515        struct_ser.end()
1516    }
1517}
1518impl<'de> serde::Deserialize<'de> for AlterConnectorPropsResponse {
1519    #[allow(deprecated)]
1520    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1521    where
1522        D: serde::Deserializer<'de>,
1523    {
1524        const FIELDS: &[&str] = &[
1525        ];
1526
1527        #[allow(clippy::enum_variant_names)]
1528        enum GeneratedField {
1529        }
1530        impl<'de> serde::Deserialize<'de> for GeneratedField {
1531            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1532            where
1533                D: serde::Deserializer<'de>,
1534            {
1535                struct GeneratedVisitor;
1536
1537                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1538                    type Value = GeneratedField;
1539
1540                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1541                        write!(formatter, "expected one of: {:?}", &FIELDS)
1542                    }
1543
1544                    #[allow(unused_variables)]
1545                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1546                    where
1547                        E: serde::de::Error,
1548                    {
1549                            Err(serde::de::Error::unknown_field(value, FIELDS))
1550                    }
1551                }
1552                deserializer.deserialize_identifier(GeneratedVisitor)
1553            }
1554        }
1555        struct GeneratedVisitor;
1556        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1557            type Value = AlterConnectorPropsResponse;
1558
1559            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1560                formatter.write_str("struct meta.AlterConnectorPropsResponse")
1561            }
1562
1563            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AlterConnectorPropsResponse, V::Error>
1564                where
1565                    V: serde::de::MapAccess<'de>,
1566            {
1567                while map_.next_key::<GeneratedField>()?.is_some() {
1568                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1569                }
1570                Ok(AlterConnectorPropsResponse {
1571                })
1572            }
1573        }
1574        deserializer.deserialize_struct("meta.AlterConnectorPropsResponse", FIELDS, GeneratedVisitor)
1575    }
1576}
1577impl serde::Serialize for ApplyThrottleRequest {
1578    #[allow(deprecated)]
1579    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1580    where
1581        S: serde::Serializer,
1582    {
1583        use serde::ser::SerializeStruct;
1584        let mut len = 0;
1585        if self.kind != 0 {
1586            len += 1;
1587        }
1588        if self.id != 0 {
1589            len += 1;
1590        }
1591        if self.rate.is_some() {
1592            len += 1;
1593        }
1594        let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleRequest", len)?;
1595        if self.kind != 0 {
1596            let v = ThrottleTarget::try_from(self.kind)
1597                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1598            struct_ser.serialize_field("kind", &v)?;
1599        }
1600        if self.id != 0 {
1601            struct_ser.serialize_field("id", &self.id)?;
1602        }
1603        if let Some(v) = self.rate.as_ref() {
1604            struct_ser.serialize_field("rate", v)?;
1605        }
1606        struct_ser.end()
1607    }
1608}
1609impl<'de> serde::Deserialize<'de> for ApplyThrottleRequest {
1610    #[allow(deprecated)]
1611    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1612    where
1613        D: serde::Deserializer<'de>,
1614    {
1615        const FIELDS: &[&str] = &[
1616            "kind",
1617            "id",
1618            "rate",
1619        ];
1620
1621        #[allow(clippy::enum_variant_names)]
1622        enum GeneratedField {
1623            Kind,
1624            Id,
1625            Rate,
1626        }
1627        impl<'de> serde::Deserialize<'de> for GeneratedField {
1628            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1629            where
1630                D: serde::Deserializer<'de>,
1631            {
1632                struct GeneratedVisitor;
1633
1634                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1635                    type Value = GeneratedField;
1636
1637                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1638                        write!(formatter, "expected one of: {:?}", &FIELDS)
1639                    }
1640
1641                    #[allow(unused_variables)]
1642                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1643                    where
1644                        E: serde::de::Error,
1645                    {
1646                        match value {
1647                            "kind" => Ok(GeneratedField::Kind),
1648                            "id" => Ok(GeneratedField::Id),
1649                            "rate" => Ok(GeneratedField::Rate),
1650                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1651                        }
1652                    }
1653                }
1654                deserializer.deserialize_identifier(GeneratedVisitor)
1655            }
1656        }
1657        struct GeneratedVisitor;
1658        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1659            type Value = ApplyThrottleRequest;
1660
1661            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1662                formatter.write_str("struct meta.ApplyThrottleRequest")
1663            }
1664
1665            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleRequest, V::Error>
1666                where
1667                    V: serde::de::MapAccess<'de>,
1668            {
1669                let mut kind__ = None;
1670                let mut id__ = None;
1671                let mut rate__ = None;
1672                while let Some(k) = map_.next_key()? {
1673                    match k {
1674                        GeneratedField::Kind => {
1675                            if kind__.is_some() {
1676                                return Err(serde::de::Error::duplicate_field("kind"));
1677                            }
1678                            kind__ = Some(map_.next_value::<ThrottleTarget>()? as i32);
1679                        }
1680                        GeneratedField::Id => {
1681                            if id__.is_some() {
1682                                return Err(serde::de::Error::duplicate_field("id"));
1683                            }
1684                            id__ = 
1685                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1686                            ;
1687                        }
1688                        GeneratedField::Rate => {
1689                            if rate__.is_some() {
1690                                return Err(serde::de::Error::duplicate_field("rate"));
1691                            }
1692                            rate__ = 
1693                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1694                            ;
1695                        }
1696                    }
1697                }
1698                Ok(ApplyThrottleRequest {
1699                    kind: kind__.unwrap_or_default(),
1700                    id: id__.unwrap_or_default(),
1701                    rate: rate__,
1702                })
1703            }
1704        }
1705        deserializer.deserialize_struct("meta.ApplyThrottleRequest", FIELDS, GeneratedVisitor)
1706    }
1707}
1708impl serde::Serialize for ApplyThrottleResponse {
1709    #[allow(deprecated)]
1710    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1711    where
1712        S: serde::Serializer,
1713    {
1714        use serde::ser::SerializeStruct;
1715        let mut len = 0;
1716        if self.status.is_some() {
1717            len += 1;
1718        }
1719        let mut struct_ser = serializer.serialize_struct("meta.ApplyThrottleResponse", len)?;
1720        if let Some(v) = self.status.as_ref() {
1721            struct_ser.serialize_field("status", v)?;
1722        }
1723        struct_ser.end()
1724    }
1725}
1726impl<'de> serde::Deserialize<'de> for ApplyThrottleResponse {
1727    #[allow(deprecated)]
1728    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1729    where
1730        D: serde::Deserializer<'de>,
1731    {
1732        const FIELDS: &[&str] = &[
1733            "status",
1734        ];
1735
1736        #[allow(clippy::enum_variant_names)]
1737        enum GeneratedField {
1738            Status,
1739        }
1740        impl<'de> serde::Deserialize<'de> for GeneratedField {
1741            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1742            where
1743                D: serde::Deserializer<'de>,
1744            {
1745                struct GeneratedVisitor;
1746
1747                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1748                    type Value = GeneratedField;
1749
1750                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1751                        write!(formatter, "expected one of: {:?}", &FIELDS)
1752                    }
1753
1754                    #[allow(unused_variables)]
1755                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1756                    where
1757                        E: serde::de::Error,
1758                    {
1759                        match value {
1760                            "status" => Ok(GeneratedField::Status),
1761                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1762                        }
1763                    }
1764                }
1765                deserializer.deserialize_identifier(GeneratedVisitor)
1766            }
1767        }
1768        struct GeneratedVisitor;
1769        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1770            type Value = ApplyThrottleResponse;
1771
1772            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1773                formatter.write_str("struct meta.ApplyThrottleResponse")
1774            }
1775
1776            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ApplyThrottleResponse, V::Error>
1777                where
1778                    V: serde::de::MapAccess<'de>,
1779            {
1780                let mut status__ = None;
1781                while let Some(k) = map_.next_key()? {
1782                    match k {
1783                        GeneratedField::Status => {
1784                            if status__.is_some() {
1785                                return Err(serde::de::Error::duplicate_field("status"));
1786                            }
1787                            status__ = map_.next_value()?;
1788                        }
1789                    }
1790                }
1791                Ok(ApplyThrottleResponse {
1792                    status: status__,
1793                })
1794            }
1795        }
1796        deserializer.deserialize_struct("meta.ApplyThrottleResponse", FIELDS, GeneratedVisitor)
1797    }
1798}
1799impl serde::Serialize for CancelCreatingJobsRequest {
1800    #[allow(deprecated)]
1801    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1802    where
1803        S: serde::Serializer,
1804    {
1805        use serde::ser::SerializeStruct;
1806        let mut len = 0;
1807        if self.jobs.is_some() {
1808            len += 1;
1809        }
1810        let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest", len)?;
1811        if let Some(v) = self.jobs.as_ref() {
1812            match v {
1813                cancel_creating_jobs_request::Jobs::Infos(v) => {
1814                    struct_ser.serialize_field("infos", v)?;
1815                }
1816                cancel_creating_jobs_request::Jobs::Ids(v) => {
1817                    struct_ser.serialize_field("ids", v)?;
1818                }
1819            }
1820        }
1821        struct_ser.end()
1822    }
1823}
1824impl<'de> serde::Deserialize<'de> for CancelCreatingJobsRequest {
1825    #[allow(deprecated)]
1826    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1827    where
1828        D: serde::Deserializer<'de>,
1829    {
1830        const FIELDS: &[&str] = &[
1831            "infos",
1832            "ids",
1833        ];
1834
1835        #[allow(clippy::enum_variant_names)]
1836        enum GeneratedField {
1837            Infos,
1838            Ids,
1839        }
1840        impl<'de> serde::Deserialize<'de> for GeneratedField {
1841            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1842            where
1843                D: serde::Deserializer<'de>,
1844            {
1845                struct GeneratedVisitor;
1846
1847                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1848                    type Value = GeneratedField;
1849
1850                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1851                        write!(formatter, "expected one of: {:?}", &FIELDS)
1852                    }
1853
1854                    #[allow(unused_variables)]
1855                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1856                    where
1857                        E: serde::de::Error,
1858                    {
1859                        match value {
1860                            "infos" => Ok(GeneratedField::Infos),
1861                            "ids" => Ok(GeneratedField::Ids),
1862                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1863                        }
1864                    }
1865                }
1866                deserializer.deserialize_identifier(GeneratedVisitor)
1867            }
1868        }
1869        struct GeneratedVisitor;
1870        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1871            type Value = CancelCreatingJobsRequest;
1872
1873            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1874                formatter.write_str("struct meta.CancelCreatingJobsRequest")
1875            }
1876
1877            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsRequest, V::Error>
1878                where
1879                    V: serde::de::MapAccess<'de>,
1880            {
1881                let mut jobs__ = None;
1882                while let Some(k) = map_.next_key()? {
1883                    match k {
1884                        GeneratedField::Infos => {
1885                            if jobs__.is_some() {
1886                                return Err(serde::de::Error::duplicate_field("infos"));
1887                            }
1888                            jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Infos)
1889;
1890                        }
1891                        GeneratedField::Ids => {
1892                            if jobs__.is_some() {
1893                                return Err(serde::de::Error::duplicate_field("ids"));
1894                            }
1895                            jobs__ = map_.next_value::<::std::option::Option<_>>()?.map(cancel_creating_jobs_request::Jobs::Ids)
1896;
1897                        }
1898                    }
1899                }
1900                Ok(CancelCreatingJobsRequest {
1901                    jobs: jobs__,
1902                })
1903            }
1904        }
1905        deserializer.deserialize_struct("meta.CancelCreatingJobsRequest", FIELDS, GeneratedVisitor)
1906    }
1907}
1908impl serde::Serialize for cancel_creating_jobs_request::CreatingJobIds {
1909    #[allow(deprecated)]
1910    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1911    where
1912        S: serde::Serializer,
1913    {
1914        use serde::ser::SerializeStruct;
1915        let mut len = 0;
1916        if !self.job_ids.is_empty() {
1917            len += 1;
1918        }
1919        let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", len)?;
1920        if !self.job_ids.is_empty() {
1921            struct_ser.serialize_field("jobIds", &self.job_ids)?;
1922        }
1923        struct_ser.end()
1924    }
1925}
1926impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobIds {
1927    #[allow(deprecated)]
1928    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1929    where
1930        D: serde::Deserializer<'de>,
1931    {
1932        const FIELDS: &[&str] = &[
1933            "job_ids",
1934            "jobIds",
1935        ];
1936
1937        #[allow(clippy::enum_variant_names)]
1938        enum GeneratedField {
1939            JobIds,
1940        }
1941        impl<'de> serde::Deserialize<'de> for GeneratedField {
1942            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1943            where
1944                D: serde::Deserializer<'de>,
1945            {
1946                struct GeneratedVisitor;
1947
1948                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1949                    type Value = GeneratedField;
1950
1951                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1952                        write!(formatter, "expected one of: {:?}", &FIELDS)
1953                    }
1954
1955                    #[allow(unused_variables)]
1956                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1957                    where
1958                        E: serde::de::Error,
1959                    {
1960                        match value {
1961                            "jobIds" | "job_ids" => Ok(GeneratedField::JobIds),
1962                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1963                        }
1964                    }
1965                }
1966                deserializer.deserialize_identifier(GeneratedVisitor)
1967            }
1968        }
1969        struct GeneratedVisitor;
1970        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1971            type Value = cancel_creating_jobs_request::CreatingJobIds;
1972
1973            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1974                formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobIds")
1975            }
1976
1977            fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobIds, V::Error>
1978                where
1979                    V: serde::de::MapAccess<'de>,
1980            {
1981                let mut job_ids__ = None;
1982                while let Some(k) = map_.next_key()? {
1983                    match k {
1984                        GeneratedField::JobIds => {
1985                            if job_ids__.is_some() {
1986                                return Err(serde::de::Error::duplicate_field("jobIds"));
1987                            }
1988                            job_ids__ = 
1989                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1990                                    .into_iter().map(|x| x.0).collect())
1991                            ;
1992                        }
1993                    }
1994                }
1995                Ok(cancel_creating_jobs_request::CreatingJobIds {
1996                    job_ids: job_ids__.unwrap_or_default(),
1997                })
1998            }
1999        }
2000        deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobIds", FIELDS, GeneratedVisitor)
2001    }
2002}
2003impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfo {
2004    #[allow(deprecated)]
2005    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2006    where
2007        S: serde::Serializer,
2008    {
2009        use serde::ser::SerializeStruct;
2010        let mut len = 0;
2011        if self.database_id != 0 {
2012            len += 1;
2013        }
2014        if self.schema_id != 0 {
2015            len += 1;
2016        }
2017        if !self.name.is_empty() {
2018            len += 1;
2019        }
2020        let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", len)?;
2021        if self.database_id != 0 {
2022            struct_ser.serialize_field("databaseId", &self.database_id)?;
2023        }
2024        if self.schema_id != 0 {
2025            struct_ser.serialize_field("schemaId", &self.schema_id)?;
2026        }
2027        if !self.name.is_empty() {
2028            struct_ser.serialize_field("name", &self.name)?;
2029        }
2030        struct_ser.end()
2031    }
2032}
2033impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfo {
2034    #[allow(deprecated)]
2035    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2036    where
2037        D: serde::Deserializer<'de>,
2038    {
2039        const FIELDS: &[&str] = &[
2040            "database_id",
2041            "databaseId",
2042            "schema_id",
2043            "schemaId",
2044            "name",
2045        ];
2046
2047        #[allow(clippy::enum_variant_names)]
2048        enum GeneratedField {
2049            DatabaseId,
2050            SchemaId,
2051            Name,
2052        }
2053        impl<'de> serde::Deserialize<'de> for GeneratedField {
2054            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2055            where
2056                D: serde::Deserializer<'de>,
2057            {
2058                struct GeneratedVisitor;
2059
2060                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2061                    type Value = GeneratedField;
2062
2063                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2064                        write!(formatter, "expected one of: {:?}", &FIELDS)
2065                    }
2066
2067                    #[allow(unused_variables)]
2068                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2069                    where
2070                        E: serde::de::Error,
2071                    {
2072                        match value {
2073                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
2074                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
2075                            "name" => Ok(GeneratedField::Name),
2076                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2077                        }
2078                    }
2079                }
2080                deserializer.deserialize_identifier(GeneratedVisitor)
2081            }
2082        }
2083        struct GeneratedVisitor;
2084        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2085            type Value = cancel_creating_jobs_request::CreatingJobInfo;
2086
2087            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2088                formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfo")
2089            }
2090
2091            fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfo, V::Error>
2092                where
2093                    V: serde::de::MapAccess<'de>,
2094            {
2095                let mut database_id__ = None;
2096                let mut schema_id__ = None;
2097                let mut name__ = None;
2098                while let Some(k) = map_.next_key()? {
2099                    match k {
2100                        GeneratedField::DatabaseId => {
2101                            if database_id__.is_some() {
2102                                return Err(serde::de::Error::duplicate_field("databaseId"));
2103                            }
2104                            database_id__ = 
2105                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2106                            ;
2107                        }
2108                        GeneratedField::SchemaId => {
2109                            if schema_id__.is_some() {
2110                                return Err(serde::de::Error::duplicate_field("schemaId"));
2111                            }
2112                            schema_id__ = 
2113                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2114                            ;
2115                        }
2116                        GeneratedField::Name => {
2117                            if name__.is_some() {
2118                                return Err(serde::de::Error::duplicate_field("name"));
2119                            }
2120                            name__ = Some(map_.next_value()?);
2121                        }
2122                    }
2123                }
2124                Ok(cancel_creating_jobs_request::CreatingJobInfo {
2125                    database_id: database_id__.unwrap_or_default(),
2126                    schema_id: schema_id__.unwrap_or_default(),
2127                    name: name__.unwrap_or_default(),
2128                })
2129            }
2130        }
2131        deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfo", FIELDS, GeneratedVisitor)
2132    }
2133}
2134impl serde::Serialize for cancel_creating_jobs_request::CreatingJobInfos {
2135    #[allow(deprecated)]
2136    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2137    where
2138        S: serde::Serializer,
2139    {
2140        use serde::ser::SerializeStruct;
2141        let mut len = 0;
2142        if !self.infos.is_empty() {
2143            len += 1;
2144        }
2145        let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", len)?;
2146        if !self.infos.is_empty() {
2147            struct_ser.serialize_field("infos", &self.infos)?;
2148        }
2149        struct_ser.end()
2150    }
2151}
2152impl<'de> serde::Deserialize<'de> for cancel_creating_jobs_request::CreatingJobInfos {
2153    #[allow(deprecated)]
2154    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2155    where
2156        D: serde::Deserializer<'de>,
2157    {
2158        const FIELDS: &[&str] = &[
2159            "infos",
2160        ];
2161
2162        #[allow(clippy::enum_variant_names)]
2163        enum GeneratedField {
2164            Infos,
2165        }
2166        impl<'de> serde::Deserialize<'de> for GeneratedField {
2167            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2168            where
2169                D: serde::Deserializer<'de>,
2170            {
2171                struct GeneratedVisitor;
2172
2173                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2174                    type Value = GeneratedField;
2175
2176                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2177                        write!(formatter, "expected one of: {:?}", &FIELDS)
2178                    }
2179
2180                    #[allow(unused_variables)]
2181                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2182                    where
2183                        E: serde::de::Error,
2184                    {
2185                        match value {
2186                            "infos" => Ok(GeneratedField::Infos),
2187                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2188                        }
2189                    }
2190                }
2191                deserializer.deserialize_identifier(GeneratedVisitor)
2192            }
2193        }
2194        struct GeneratedVisitor;
2195        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2196            type Value = cancel_creating_jobs_request::CreatingJobInfos;
2197
2198            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2199                formatter.write_str("struct meta.CancelCreatingJobsRequest.CreatingJobInfos")
2200            }
2201
2202            fn visit_map<V>(self, mut map_: V) -> std::result::Result<cancel_creating_jobs_request::CreatingJobInfos, V::Error>
2203                where
2204                    V: serde::de::MapAccess<'de>,
2205            {
2206                let mut infos__ = None;
2207                while let Some(k) = map_.next_key()? {
2208                    match k {
2209                        GeneratedField::Infos => {
2210                            if infos__.is_some() {
2211                                return Err(serde::de::Error::duplicate_field("infos"));
2212                            }
2213                            infos__ = Some(map_.next_value()?);
2214                        }
2215                    }
2216                }
2217                Ok(cancel_creating_jobs_request::CreatingJobInfos {
2218                    infos: infos__.unwrap_or_default(),
2219                })
2220            }
2221        }
2222        deserializer.deserialize_struct("meta.CancelCreatingJobsRequest.CreatingJobInfos", FIELDS, GeneratedVisitor)
2223    }
2224}
2225impl serde::Serialize for CancelCreatingJobsResponse {
2226    #[allow(deprecated)]
2227    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2228    where
2229        S: serde::Serializer,
2230    {
2231        use serde::ser::SerializeStruct;
2232        let mut len = 0;
2233        if self.status.is_some() {
2234            len += 1;
2235        }
2236        if !self.canceled_jobs.is_empty() {
2237            len += 1;
2238        }
2239        let mut struct_ser = serializer.serialize_struct("meta.CancelCreatingJobsResponse", len)?;
2240        if let Some(v) = self.status.as_ref() {
2241            struct_ser.serialize_field("status", v)?;
2242        }
2243        if !self.canceled_jobs.is_empty() {
2244            struct_ser.serialize_field("canceledJobs", &self.canceled_jobs)?;
2245        }
2246        struct_ser.end()
2247    }
2248}
2249impl<'de> serde::Deserialize<'de> for CancelCreatingJobsResponse {
2250    #[allow(deprecated)]
2251    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2252    where
2253        D: serde::Deserializer<'de>,
2254    {
2255        const FIELDS: &[&str] = &[
2256            "status",
2257            "canceled_jobs",
2258            "canceledJobs",
2259        ];
2260
2261        #[allow(clippy::enum_variant_names)]
2262        enum GeneratedField {
2263            Status,
2264            CanceledJobs,
2265        }
2266        impl<'de> serde::Deserialize<'de> for GeneratedField {
2267            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2268            where
2269                D: serde::Deserializer<'de>,
2270            {
2271                struct GeneratedVisitor;
2272
2273                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2274                    type Value = GeneratedField;
2275
2276                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2277                        write!(formatter, "expected one of: {:?}", &FIELDS)
2278                    }
2279
2280                    #[allow(unused_variables)]
2281                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2282                    where
2283                        E: serde::de::Error,
2284                    {
2285                        match value {
2286                            "status" => Ok(GeneratedField::Status),
2287                            "canceledJobs" | "canceled_jobs" => Ok(GeneratedField::CanceledJobs),
2288                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2289                        }
2290                    }
2291                }
2292                deserializer.deserialize_identifier(GeneratedVisitor)
2293            }
2294        }
2295        struct GeneratedVisitor;
2296        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2297            type Value = CancelCreatingJobsResponse;
2298
2299            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2300                formatter.write_str("struct meta.CancelCreatingJobsResponse")
2301            }
2302
2303            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CancelCreatingJobsResponse, V::Error>
2304                where
2305                    V: serde::de::MapAccess<'de>,
2306            {
2307                let mut status__ = None;
2308                let mut canceled_jobs__ = None;
2309                while let Some(k) = map_.next_key()? {
2310                    match k {
2311                        GeneratedField::Status => {
2312                            if status__.is_some() {
2313                                return Err(serde::de::Error::duplicate_field("status"));
2314                            }
2315                            status__ = map_.next_value()?;
2316                        }
2317                        GeneratedField::CanceledJobs => {
2318                            if canceled_jobs__.is_some() {
2319                                return Err(serde::de::Error::duplicate_field("canceledJobs"));
2320                            }
2321                            canceled_jobs__ = 
2322                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2323                                    .into_iter().map(|x| x.0).collect())
2324                            ;
2325                        }
2326                    }
2327                }
2328                Ok(CancelCreatingJobsResponse {
2329                    status: status__,
2330                    canceled_jobs: canceled_jobs__.unwrap_or_default(),
2331                })
2332            }
2333        }
2334        deserializer.deserialize_struct("meta.CancelCreatingJobsResponse", FIELDS, GeneratedVisitor)
2335    }
2336}
2337impl serde::Serialize for ClusterLimit {
2338    #[allow(deprecated)]
2339    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2340    where
2341        S: serde::Serializer,
2342    {
2343        use serde::ser::SerializeStruct;
2344        let mut len = 0;
2345        if self.limit.is_some() {
2346            len += 1;
2347        }
2348        let mut struct_ser = serializer.serialize_struct("meta.ClusterLimit", len)?;
2349        if let Some(v) = self.limit.as_ref() {
2350            match v {
2351                cluster_limit::Limit::ActorCount(v) => {
2352                    struct_ser.serialize_field("actorCount", v)?;
2353                }
2354            }
2355        }
2356        struct_ser.end()
2357    }
2358}
2359impl<'de> serde::Deserialize<'de> for ClusterLimit {
2360    #[allow(deprecated)]
2361    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2362    where
2363        D: serde::Deserializer<'de>,
2364    {
2365        const FIELDS: &[&str] = &[
2366            "actor_count",
2367            "actorCount",
2368        ];
2369
2370        #[allow(clippy::enum_variant_names)]
2371        enum GeneratedField {
2372            ActorCount,
2373        }
2374        impl<'de> serde::Deserialize<'de> for GeneratedField {
2375            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2376            where
2377                D: serde::Deserializer<'de>,
2378            {
2379                struct GeneratedVisitor;
2380
2381                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2382                    type Value = GeneratedField;
2383
2384                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2385                        write!(formatter, "expected one of: {:?}", &FIELDS)
2386                    }
2387
2388                    #[allow(unused_variables)]
2389                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2390                    where
2391                        E: serde::de::Error,
2392                    {
2393                        match value {
2394                            "actorCount" | "actor_count" => Ok(GeneratedField::ActorCount),
2395                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2396                        }
2397                    }
2398                }
2399                deserializer.deserialize_identifier(GeneratedVisitor)
2400            }
2401        }
2402        struct GeneratedVisitor;
2403        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2404            type Value = ClusterLimit;
2405
2406            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2407                formatter.write_str("struct meta.ClusterLimit")
2408            }
2409
2410            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ClusterLimit, V::Error>
2411                where
2412                    V: serde::de::MapAccess<'de>,
2413            {
2414                let mut limit__ = None;
2415                while let Some(k) = map_.next_key()? {
2416                    match k {
2417                        GeneratedField::ActorCount => {
2418                            if limit__.is_some() {
2419                                return Err(serde::de::Error::duplicate_field("actorCount"));
2420                            }
2421                            limit__ = map_.next_value::<::std::option::Option<_>>()?.map(cluster_limit::Limit::ActorCount)
2422;
2423                        }
2424                    }
2425                }
2426                Ok(ClusterLimit {
2427                    limit: limit__,
2428                })
2429            }
2430        }
2431        deserializer.deserialize_struct("meta.ClusterLimit", FIELDS, GeneratedVisitor)
2432    }
2433}
2434impl serde::Serialize for DeleteWorkerNodeRequest {
2435    #[allow(deprecated)]
2436    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2437    where
2438        S: serde::Serializer,
2439    {
2440        use serde::ser::SerializeStruct;
2441        let mut len = 0;
2442        if self.host.is_some() {
2443            len += 1;
2444        }
2445        let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeRequest", len)?;
2446        if let Some(v) = self.host.as_ref() {
2447            struct_ser.serialize_field("host", v)?;
2448        }
2449        struct_ser.end()
2450    }
2451}
2452impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeRequest {
2453    #[allow(deprecated)]
2454    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2455    where
2456        D: serde::Deserializer<'de>,
2457    {
2458        const FIELDS: &[&str] = &[
2459            "host",
2460        ];
2461
2462        #[allow(clippy::enum_variant_names)]
2463        enum GeneratedField {
2464            Host,
2465        }
2466        impl<'de> serde::Deserialize<'de> for GeneratedField {
2467            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2468            where
2469                D: serde::Deserializer<'de>,
2470            {
2471                struct GeneratedVisitor;
2472
2473                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2474                    type Value = GeneratedField;
2475
2476                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2477                        write!(formatter, "expected one of: {:?}", &FIELDS)
2478                    }
2479
2480                    #[allow(unused_variables)]
2481                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2482                    where
2483                        E: serde::de::Error,
2484                    {
2485                        match value {
2486                            "host" => Ok(GeneratedField::Host),
2487                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2488                        }
2489                    }
2490                }
2491                deserializer.deserialize_identifier(GeneratedVisitor)
2492            }
2493        }
2494        struct GeneratedVisitor;
2495        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2496            type Value = DeleteWorkerNodeRequest;
2497
2498            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2499                formatter.write_str("struct meta.DeleteWorkerNodeRequest")
2500            }
2501
2502            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeRequest, V::Error>
2503                where
2504                    V: serde::de::MapAccess<'de>,
2505            {
2506                let mut host__ = None;
2507                while let Some(k) = map_.next_key()? {
2508                    match k {
2509                        GeneratedField::Host => {
2510                            if host__.is_some() {
2511                                return Err(serde::de::Error::duplicate_field("host"));
2512                            }
2513                            host__ = map_.next_value()?;
2514                        }
2515                    }
2516                }
2517                Ok(DeleteWorkerNodeRequest {
2518                    host: host__,
2519                })
2520            }
2521        }
2522        deserializer.deserialize_struct("meta.DeleteWorkerNodeRequest", FIELDS, GeneratedVisitor)
2523    }
2524}
2525impl serde::Serialize for DeleteWorkerNodeResponse {
2526    #[allow(deprecated)]
2527    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2528    where
2529        S: serde::Serializer,
2530    {
2531        use serde::ser::SerializeStruct;
2532        let mut len = 0;
2533        if self.status.is_some() {
2534            len += 1;
2535        }
2536        let mut struct_ser = serializer.serialize_struct("meta.DeleteWorkerNodeResponse", len)?;
2537        if let Some(v) = self.status.as_ref() {
2538            struct_ser.serialize_field("status", v)?;
2539        }
2540        struct_ser.end()
2541    }
2542}
2543impl<'de> serde::Deserialize<'de> for DeleteWorkerNodeResponse {
2544    #[allow(deprecated)]
2545    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2546    where
2547        D: serde::Deserializer<'de>,
2548    {
2549        const FIELDS: &[&str] = &[
2550            "status",
2551        ];
2552
2553        #[allow(clippy::enum_variant_names)]
2554        enum GeneratedField {
2555            Status,
2556        }
2557        impl<'de> serde::Deserialize<'de> for GeneratedField {
2558            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2559            where
2560                D: serde::Deserializer<'de>,
2561            {
2562                struct GeneratedVisitor;
2563
2564                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2565                    type Value = GeneratedField;
2566
2567                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2568                        write!(formatter, "expected one of: {:?}", &FIELDS)
2569                    }
2570
2571                    #[allow(unused_variables)]
2572                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2573                    where
2574                        E: serde::de::Error,
2575                    {
2576                        match value {
2577                            "status" => Ok(GeneratedField::Status),
2578                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2579                        }
2580                    }
2581                }
2582                deserializer.deserialize_identifier(GeneratedVisitor)
2583            }
2584        }
2585        struct GeneratedVisitor;
2586        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2587            type Value = DeleteWorkerNodeResponse;
2588
2589            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2590                formatter.write_str("struct meta.DeleteWorkerNodeResponse")
2591            }
2592
2593            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeleteWorkerNodeResponse, V::Error>
2594                where
2595                    V: serde::de::MapAccess<'de>,
2596            {
2597                let mut status__ = None;
2598                while let Some(k) = map_.next_key()? {
2599                    match k {
2600                        GeneratedField::Status => {
2601                            if status__.is_some() {
2602                                return Err(serde::de::Error::duplicate_field("status"));
2603                            }
2604                            status__ = map_.next_value()?;
2605                        }
2606                    }
2607                }
2608                Ok(DeleteWorkerNodeResponse {
2609                    status: status__,
2610                })
2611            }
2612        }
2613        deserializer.deserialize_struct("meta.DeleteWorkerNodeResponse", FIELDS, GeneratedVisitor)
2614    }
2615}
2616impl serde::Serialize for EventLog {
2617    #[allow(deprecated)]
2618    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2619    where
2620        S: serde::Serializer,
2621    {
2622        use serde::ser::SerializeStruct;
2623        let mut len = 0;
2624        if self.unique_id.is_some() {
2625            len += 1;
2626        }
2627        if self.timestamp.is_some() {
2628            len += 1;
2629        }
2630        if self.event.is_some() {
2631            len += 1;
2632        }
2633        let mut struct_ser = serializer.serialize_struct("meta.EventLog", len)?;
2634        if let Some(v) = self.unique_id.as_ref() {
2635            struct_ser.serialize_field("uniqueId", v)?;
2636        }
2637        if let Some(v) = self.timestamp.as_ref() {
2638            #[allow(clippy::needless_borrow)]
2639            #[allow(clippy::needless_borrows_for_generic_args)]
2640            struct_ser.serialize_field("timestamp", ToString::to_string(&v).as_str())?;
2641        }
2642        if let Some(v) = self.event.as_ref() {
2643            match v {
2644                event_log::Event::CreateStreamJobFail(v) => {
2645                    struct_ser.serialize_field("createStreamJobFail", v)?;
2646                }
2647                event_log::Event::DirtyStreamJobClear(v) => {
2648                    struct_ser.serialize_field("dirtyStreamJobClear", v)?;
2649                }
2650                event_log::Event::MetaNodeStart(v) => {
2651                    struct_ser.serialize_field("metaNodeStart", v)?;
2652                }
2653                event_log::Event::BarrierComplete(v) => {
2654                    struct_ser.serialize_field("barrierComplete", v)?;
2655                }
2656                event_log::Event::InjectBarrierFail(v) => {
2657                    struct_ser.serialize_field("injectBarrierFail", v)?;
2658                }
2659                event_log::Event::CollectBarrierFail(v) => {
2660                    struct_ser.serialize_field("collectBarrierFail", v)?;
2661                }
2662                event_log::Event::WorkerNodePanic(v) => {
2663                    struct_ser.serialize_field("workerNodePanic", v)?;
2664                }
2665                event_log::Event::AutoSchemaChangeFail(v) => {
2666                    struct_ser.serialize_field("autoSchemaChangeFail", v)?;
2667                }
2668                event_log::Event::SinkFail(v) => {
2669                    struct_ser.serialize_field("sinkFail", v)?;
2670                }
2671                event_log::Event::Recovery(v) => {
2672                    struct_ser.serialize_field("recovery", v)?;
2673                }
2674            }
2675        }
2676        struct_ser.end()
2677    }
2678}
2679impl<'de> serde::Deserialize<'de> for EventLog {
2680    #[allow(deprecated)]
2681    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2682    where
2683        D: serde::Deserializer<'de>,
2684    {
2685        const FIELDS: &[&str] = &[
2686            "unique_id",
2687            "uniqueId",
2688            "timestamp",
2689            "create_stream_job_fail",
2690            "createStreamJobFail",
2691            "dirty_stream_job_clear",
2692            "dirtyStreamJobClear",
2693            "meta_node_start",
2694            "metaNodeStart",
2695            "barrier_complete",
2696            "barrierComplete",
2697            "inject_barrier_fail",
2698            "injectBarrierFail",
2699            "collect_barrier_fail",
2700            "collectBarrierFail",
2701            "worker_node_panic",
2702            "workerNodePanic",
2703            "auto_schema_change_fail",
2704            "autoSchemaChangeFail",
2705            "sink_fail",
2706            "sinkFail",
2707            "recovery",
2708        ];
2709
2710        #[allow(clippy::enum_variant_names)]
2711        enum GeneratedField {
2712            UniqueId,
2713            Timestamp,
2714            CreateStreamJobFail,
2715            DirtyStreamJobClear,
2716            MetaNodeStart,
2717            BarrierComplete,
2718            InjectBarrierFail,
2719            CollectBarrierFail,
2720            WorkerNodePanic,
2721            AutoSchemaChangeFail,
2722            SinkFail,
2723            Recovery,
2724        }
2725        impl<'de> serde::Deserialize<'de> for GeneratedField {
2726            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2727            where
2728                D: serde::Deserializer<'de>,
2729            {
2730                struct GeneratedVisitor;
2731
2732                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2733                    type Value = GeneratedField;
2734
2735                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2736                        write!(formatter, "expected one of: {:?}", &FIELDS)
2737                    }
2738
2739                    #[allow(unused_variables)]
2740                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2741                    where
2742                        E: serde::de::Error,
2743                    {
2744                        match value {
2745                            "uniqueId" | "unique_id" => Ok(GeneratedField::UniqueId),
2746                            "timestamp" => Ok(GeneratedField::Timestamp),
2747                            "createStreamJobFail" | "create_stream_job_fail" => Ok(GeneratedField::CreateStreamJobFail),
2748                            "dirtyStreamJobClear" | "dirty_stream_job_clear" => Ok(GeneratedField::DirtyStreamJobClear),
2749                            "metaNodeStart" | "meta_node_start" => Ok(GeneratedField::MetaNodeStart),
2750                            "barrierComplete" | "barrier_complete" => Ok(GeneratedField::BarrierComplete),
2751                            "injectBarrierFail" | "inject_barrier_fail" => Ok(GeneratedField::InjectBarrierFail),
2752                            "collectBarrierFail" | "collect_barrier_fail" => Ok(GeneratedField::CollectBarrierFail),
2753                            "workerNodePanic" | "worker_node_panic" => Ok(GeneratedField::WorkerNodePanic),
2754                            "autoSchemaChangeFail" | "auto_schema_change_fail" => Ok(GeneratedField::AutoSchemaChangeFail),
2755                            "sinkFail" | "sink_fail" => Ok(GeneratedField::SinkFail),
2756                            "recovery" => Ok(GeneratedField::Recovery),
2757                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2758                        }
2759                    }
2760                }
2761                deserializer.deserialize_identifier(GeneratedVisitor)
2762            }
2763        }
2764        struct GeneratedVisitor;
2765        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2766            type Value = EventLog;
2767
2768            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2769                formatter.write_str("struct meta.EventLog")
2770            }
2771
2772            fn visit_map<V>(self, mut map_: V) -> std::result::Result<EventLog, V::Error>
2773                where
2774                    V: serde::de::MapAccess<'de>,
2775            {
2776                let mut unique_id__ = None;
2777                let mut timestamp__ = None;
2778                let mut event__ = None;
2779                while let Some(k) = map_.next_key()? {
2780                    match k {
2781                        GeneratedField::UniqueId => {
2782                            if unique_id__.is_some() {
2783                                return Err(serde::de::Error::duplicate_field("uniqueId"));
2784                            }
2785                            unique_id__ = map_.next_value()?;
2786                        }
2787                        GeneratedField::Timestamp => {
2788                            if timestamp__.is_some() {
2789                                return Err(serde::de::Error::duplicate_field("timestamp"));
2790                            }
2791                            timestamp__ = 
2792                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
2793                            ;
2794                        }
2795                        GeneratedField::CreateStreamJobFail => {
2796                            if event__.is_some() {
2797                                return Err(serde::de::Error::duplicate_field("createStreamJobFail"));
2798                            }
2799                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CreateStreamJobFail)
2800;
2801                        }
2802                        GeneratedField::DirtyStreamJobClear => {
2803                            if event__.is_some() {
2804                                return Err(serde::de::Error::duplicate_field("dirtyStreamJobClear"));
2805                            }
2806                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::DirtyStreamJobClear)
2807;
2808                        }
2809                        GeneratedField::MetaNodeStart => {
2810                            if event__.is_some() {
2811                                return Err(serde::de::Error::duplicate_field("metaNodeStart"));
2812                            }
2813                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::MetaNodeStart)
2814;
2815                        }
2816                        GeneratedField::BarrierComplete => {
2817                            if event__.is_some() {
2818                                return Err(serde::de::Error::duplicate_field("barrierComplete"));
2819                            }
2820                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::BarrierComplete)
2821;
2822                        }
2823                        GeneratedField::InjectBarrierFail => {
2824                            if event__.is_some() {
2825                                return Err(serde::de::Error::duplicate_field("injectBarrierFail"));
2826                            }
2827                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::InjectBarrierFail)
2828;
2829                        }
2830                        GeneratedField::CollectBarrierFail => {
2831                            if event__.is_some() {
2832                                return Err(serde::de::Error::duplicate_field("collectBarrierFail"));
2833                            }
2834                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::CollectBarrierFail)
2835;
2836                        }
2837                        GeneratedField::WorkerNodePanic => {
2838                            if event__.is_some() {
2839                                return Err(serde::de::Error::duplicate_field("workerNodePanic"));
2840                            }
2841                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::WorkerNodePanic)
2842;
2843                        }
2844                        GeneratedField::AutoSchemaChangeFail => {
2845                            if event__.is_some() {
2846                                return Err(serde::de::Error::duplicate_field("autoSchemaChangeFail"));
2847                            }
2848                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::AutoSchemaChangeFail)
2849;
2850                        }
2851                        GeneratedField::SinkFail => {
2852                            if event__.is_some() {
2853                                return Err(serde::de::Error::duplicate_field("sinkFail"));
2854                            }
2855                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::SinkFail)
2856;
2857                        }
2858                        GeneratedField::Recovery => {
2859                            if event__.is_some() {
2860                                return Err(serde::de::Error::duplicate_field("recovery"));
2861                            }
2862                            event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::Event::Recovery)
2863;
2864                        }
2865                    }
2866                }
2867                Ok(EventLog {
2868                    unique_id: unique_id__,
2869                    timestamp: timestamp__,
2870                    event: event__,
2871                })
2872            }
2873        }
2874        deserializer.deserialize_struct("meta.EventLog", FIELDS, GeneratedVisitor)
2875    }
2876}
2877impl serde::Serialize for event_log::EventAutoSchemaChangeFail {
2878    #[allow(deprecated)]
2879    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2880    where
2881        S: serde::Serializer,
2882    {
2883        use serde::ser::SerializeStruct;
2884        let mut len = 0;
2885        if self.table_id != 0 {
2886            len += 1;
2887        }
2888        if !self.table_name.is_empty() {
2889            len += 1;
2890        }
2891        if !self.cdc_table_id.is_empty() {
2892            len += 1;
2893        }
2894        if !self.upstream_ddl.is_empty() {
2895            len += 1;
2896        }
2897        if !self.fail_info.is_empty() {
2898            len += 1;
2899        }
2900        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventAutoSchemaChangeFail", len)?;
2901        if self.table_id != 0 {
2902            struct_ser.serialize_field("tableId", &self.table_id)?;
2903        }
2904        if !self.table_name.is_empty() {
2905            struct_ser.serialize_field("tableName", &self.table_name)?;
2906        }
2907        if !self.cdc_table_id.is_empty() {
2908            struct_ser.serialize_field("cdcTableId", &self.cdc_table_id)?;
2909        }
2910        if !self.upstream_ddl.is_empty() {
2911            struct_ser.serialize_field("upstreamDdl", &self.upstream_ddl)?;
2912        }
2913        if !self.fail_info.is_empty() {
2914            struct_ser.serialize_field("failInfo", &self.fail_info)?;
2915        }
2916        struct_ser.end()
2917    }
2918}
2919impl<'de> serde::Deserialize<'de> for event_log::EventAutoSchemaChangeFail {
2920    #[allow(deprecated)]
2921    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2922    where
2923        D: serde::Deserializer<'de>,
2924    {
2925        const FIELDS: &[&str] = &[
2926            "table_id",
2927            "tableId",
2928            "table_name",
2929            "tableName",
2930            "cdc_table_id",
2931            "cdcTableId",
2932            "upstream_ddl",
2933            "upstreamDdl",
2934            "fail_info",
2935            "failInfo",
2936        ];
2937
2938        #[allow(clippy::enum_variant_names)]
2939        enum GeneratedField {
2940            TableId,
2941            TableName,
2942            CdcTableId,
2943            UpstreamDdl,
2944            FailInfo,
2945        }
2946        impl<'de> serde::Deserialize<'de> for GeneratedField {
2947            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2948            where
2949                D: serde::Deserializer<'de>,
2950            {
2951                struct GeneratedVisitor;
2952
2953                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2954                    type Value = GeneratedField;
2955
2956                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2957                        write!(formatter, "expected one of: {:?}", &FIELDS)
2958                    }
2959
2960                    #[allow(unused_variables)]
2961                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2962                    where
2963                        E: serde::de::Error,
2964                    {
2965                        match value {
2966                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
2967                            "tableName" | "table_name" => Ok(GeneratedField::TableName),
2968                            "cdcTableId" | "cdc_table_id" => Ok(GeneratedField::CdcTableId),
2969                            "upstreamDdl" | "upstream_ddl" => Ok(GeneratedField::UpstreamDdl),
2970                            "failInfo" | "fail_info" => Ok(GeneratedField::FailInfo),
2971                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2972                        }
2973                    }
2974                }
2975                deserializer.deserialize_identifier(GeneratedVisitor)
2976            }
2977        }
2978        struct GeneratedVisitor;
2979        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2980            type Value = event_log::EventAutoSchemaChangeFail;
2981
2982            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2983                formatter.write_str("struct meta.EventLog.EventAutoSchemaChangeFail")
2984            }
2985
2986            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventAutoSchemaChangeFail, V::Error>
2987                where
2988                    V: serde::de::MapAccess<'de>,
2989            {
2990                let mut table_id__ = None;
2991                let mut table_name__ = None;
2992                let mut cdc_table_id__ = None;
2993                let mut upstream_ddl__ = None;
2994                let mut fail_info__ = None;
2995                while let Some(k) = map_.next_key()? {
2996                    match k {
2997                        GeneratedField::TableId => {
2998                            if table_id__.is_some() {
2999                                return Err(serde::de::Error::duplicate_field("tableId"));
3000                            }
3001                            table_id__ = 
3002                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3003                            ;
3004                        }
3005                        GeneratedField::TableName => {
3006                            if table_name__.is_some() {
3007                                return Err(serde::de::Error::duplicate_field("tableName"));
3008                            }
3009                            table_name__ = Some(map_.next_value()?);
3010                        }
3011                        GeneratedField::CdcTableId => {
3012                            if cdc_table_id__.is_some() {
3013                                return Err(serde::de::Error::duplicate_field("cdcTableId"));
3014                            }
3015                            cdc_table_id__ = Some(map_.next_value()?);
3016                        }
3017                        GeneratedField::UpstreamDdl => {
3018                            if upstream_ddl__.is_some() {
3019                                return Err(serde::de::Error::duplicate_field("upstreamDdl"));
3020                            }
3021                            upstream_ddl__ = Some(map_.next_value()?);
3022                        }
3023                        GeneratedField::FailInfo => {
3024                            if fail_info__.is_some() {
3025                                return Err(serde::de::Error::duplicate_field("failInfo"));
3026                            }
3027                            fail_info__ = Some(map_.next_value()?);
3028                        }
3029                    }
3030                }
3031                Ok(event_log::EventAutoSchemaChangeFail {
3032                    table_id: table_id__.unwrap_or_default(),
3033                    table_name: table_name__.unwrap_or_default(),
3034                    cdc_table_id: cdc_table_id__.unwrap_or_default(),
3035                    upstream_ddl: upstream_ddl__.unwrap_or_default(),
3036                    fail_info: fail_info__.unwrap_or_default(),
3037                })
3038            }
3039        }
3040        deserializer.deserialize_struct("meta.EventLog.EventAutoSchemaChangeFail", FIELDS, GeneratedVisitor)
3041    }
3042}
3043impl serde::Serialize for event_log::EventBarrierComplete {
3044    #[allow(deprecated)]
3045    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3046    where
3047        S: serde::Serializer,
3048    {
3049        use serde::ser::SerializeStruct;
3050        let mut len = 0;
3051        if self.prev_epoch != 0 {
3052            len += 1;
3053        }
3054        if self.cur_epoch != 0 {
3055            len += 1;
3056        }
3057        if self.duration_sec != 0. {
3058            len += 1;
3059        }
3060        if !self.command.is_empty() {
3061            len += 1;
3062        }
3063        if !self.barrier_kind.is_empty() {
3064            len += 1;
3065        }
3066        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventBarrierComplete", len)?;
3067        if self.prev_epoch != 0 {
3068            #[allow(clippy::needless_borrow)]
3069            #[allow(clippy::needless_borrows_for_generic_args)]
3070            struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3071        }
3072        if self.cur_epoch != 0 {
3073            #[allow(clippy::needless_borrow)]
3074            #[allow(clippy::needless_borrows_for_generic_args)]
3075            struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3076        }
3077        if self.duration_sec != 0. {
3078            struct_ser.serialize_field("durationSec", &self.duration_sec)?;
3079        }
3080        if !self.command.is_empty() {
3081            struct_ser.serialize_field("command", &self.command)?;
3082        }
3083        if !self.barrier_kind.is_empty() {
3084            struct_ser.serialize_field("barrierKind", &self.barrier_kind)?;
3085        }
3086        struct_ser.end()
3087    }
3088}
3089impl<'de> serde::Deserialize<'de> for event_log::EventBarrierComplete {
3090    #[allow(deprecated)]
3091    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3092    where
3093        D: serde::Deserializer<'de>,
3094    {
3095        const FIELDS: &[&str] = &[
3096            "prev_epoch",
3097            "prevEpoch",
3098            "cur_epoch",
3099            "curEpoch",
3100            "duration_sec",
3101            "durationSec",
3102            "command",
3103            "barrier_kind",
3104            "barrierKind",
3105        ];
3106
3107        #[allow(clippy::enum_variant_names)]
3108        enum GeneratedField {
3109            PrevEpoch,
3110            CurEpoch,
3111            DurationSec,
3112            Command,
3113            BarrierKind,
3114        }
3115        impl<'de> serde::Deserialize<'de> for GeneratedField {
3116            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3117            where
3118                D: serde::Deserializer<'de>,
3119            {
3120                struct GeneratedVisitor;
3121
3122                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3123                    type Value = GeneratedField;
3124
3125                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3126                        write!(formatter, "expected one of: {:?}", &FIELDS)
3127                    }
3128
3129                    #[allow(unused_variables)]
3130                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3131                    where
3132                        E: serde::de::Error,
3133                    {
3134                        match value {
3135                            "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3136                            "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3137                            "durationSec" | "duration_sec" => Ok(GeneratedField::DurationSec),
3138                            "command" => Ok(GeneratedField::Command),
3139                            "barrierKind" | "barrier_kind" => Ok(GeneratedField::BarrierKind),
3140                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3141                        }
3142                    }
3143                }
3144                deserializer.deserialize_identifier(GeneratedVisitor)
3145            }
3146        }
3147        struct GeneratedVisitor;
3148        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3149            type Value = event_log::EventBarrierComplete;
3150
3151            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3152                formatter.write_str("struct meta.EventLog.EventBarrierComplete")
3153            }
3154
3155            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventBarrierComplete, V::Error>
3156                where
3157                    V: serde::de::MapAccess<'de>,
3158            {
3159                let mut prev_epoch__ = None;
3160                let mut cur_epoch__ = None;
3161                let mut duration_sec__ = None;
3162                let mut command__ = None;
3163                let mut barrier_kind__ = None;
3164                while let Some(k) = map_.next_key()? {
3165                    match k {
3166                        GeneratedField::PrevEpoch => {
3167                            if prev_epoch__.is_some() {
3168                                return Err(serde::de::Error::duplicate_field("prevEpoch"));
3169                            }
3170                            prev_epoch__ = 
3171                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3172                            ;
3173                        }
3174                        GeneratedField::CurEpoch => {
3175                            if cur_epoch__.is_some() {
3176                                return Err(serde::de::Error::duplicate_field("curEpoch"));
3177                            }
3178                            cur_epoch__ = 
3179                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3180                            ;
3181                        }
3182                        GeneratedField::DurationSec => {
3183                            if duration_sec__.is_some() {
3184                                return Err(serde::de::Error::duplicate_field("durationSec"));
3185                            }
3186                            duration_sec__ = 
3187                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3188                            ;
3189                        }
3190                        GeneratedField::Command => {
3191                            if command__.is_some() {
3192                                return Err(serde::de::Error::duplicate_field("command"));
3193                            }
3194                            command__ = Some(map_.next_value()?);
3195                        }
3196                        GeneratedField::BarrierKind => {
3197                            if barrier_kind__.is_some() {
3198                                return Err(serde::de::Error::duplicate_field("barrierKind"));
3199                            }
3200                            barrier_kind__ = Some(map_.next_value()?);
3201                        }
3202                    }
3203                }
3204                Ok(event_log::EventBarrierComplete {
3205                    prev_epoch: prev_epoch__.unwrap_or_default(),
3206                    cur_epoch: cur_epoch__.unwrap_or_default(),
3207                    duration_sec: duration_sec__.unwrap_or_default(),
3208                    command: command__.unwrap_or_default(),
3209                    barrier_kind: barrier_kind__.unwrap_or_default(),
3210                })
3211            }
3212        }
3213        deserializer.deserialize_struct("meta.EventLog.EventBarrierComplete", FIELDS, GeneratedVisitor)
3214    }
3215}
3216impl serde::Serialize for event_log::EventCollectBarrierFail {
3217    #[allow(deprecated)]
3218    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3219    where
3220        S: serde::Serializer,
3221    {
3222        use serde::ser::SerializeStruct;
3223        let mut len = 0;
3224        if !self.error.is_empty() {
3225            len += 1;
3226        }
3227        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCollectBarrierFail", len)?;
3228        if !self.error.is_empty() {
3229            struct_ser.serialize_field("error", &self.error)?;
3230        }
3231        struct_ser.end()
3232    }
3233}
3234impl<'de> serde::Deserialize<'de> for event_log::EventCollectBarrierFail {
3235    #[allow(deprecated)]
3236    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3237    where
3238        D: serde::Deserializer<'de>,
3239    {
3240        const FIELDS: &[&str] = &[
3241            "error",
3242        ];
3243
3244        #[allow(clippy::enum_variant_names)]
3245        enum GeneratedField {
3246            Error,
3247        }
3248        impl<'de> serde::Deserialize<'de> for GeneratedField {
3249            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3250            where
3251                D: serde::Deserializer<'de>,
3252            {
3253                struct GeneratedVisitor;
3254
3255                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3256                    type Value = GeneratedField;
3257
3258                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3259                        write!(formatter, "expected one of: {:?}", &FIELDS)
3260                    }
3261
3262                    #[allow(unused_variables)]
3263                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3264                    where
3265                        E: serde::de::Error,
3266                    {
3267                        match value {
3268                            "error" => Ok(GeneratedField::Error),
3269                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3270                        }
3271                    }
3272                }
3273                deserializer.deserialize_identifier(GeneratedVisitor)
3274            }
3275        }
3276        struct GeneratedVisitor;
3277        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3278            type Value = event_log::EventCollectBarrierFail;
3279
3280            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3281                formatter.write_str("struct meta.EventLog.EventCollectBarrierFail")
3282            }
3283
3284            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCollectBarrierFail, V::Error>
3285                where
3286                    V: serde::de::MapAccess<'de>,
3287            {
3288                let mut error__ = None;
3289                while let Some(k) = map_.next_key()? {
3290                    match k {
3291                        GeneratedField::Error => {
3292                            if error__.is_some() {
3293                                return Err(serde::de::Error::duplicate_field("error"));
3294                            }
3295                            error__ = Some(map_.next_value()?);
3296                        }
3297                    }
3298                }
3299                Ok(event_log::EventCollectBarrierFail {
3300                    error: error__.unwrap_or_default(),
3301                })
3302            }
3303        }
3304        deserializer.deserialize_struct("meta.EventLog.EventCollectBarrierFail", FIELDS, GeneratedVisitor)
3305    }
3306}
3307impl serde::Serialize for event_log::EventCreateStreamJobFail {
3308    #[allow(deprecated)]
3309    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3310    where
3311        S: serde::Serializer,
3312    {
3313        use serde::ser::SerializeStruct;
3314        let mut len = 0;
3315        if self.id != 0 {
3316            len += 1;
3317        }
3318        if !self.name.is_empty() {
3319            len += 1;
3320        }
3321        if !self.definition.is_empty() {
3322            len += 1;
3323        }
3324        if !self.error.is_empty() {
3325            len += 1;
3326        }
3327        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventCreateStreamJobFail", len)?;
3328        if self.id != 0 {
3329            struct_ser.serialize_field("id", &self.id)?;
3330        }
3331        if !self.name.is_empty() {
3332            struct_ser.serialize_field("name", &self.name)?;
3333        }
3334        if !self.definition.is_empty() {
3335            struct_ser.serialize_field("definition", &self.definition)?;
3336        }
3337        if !self.error.is_empty() {
3338            struct_ser.serialize_field("error", &self.error)?;
3339        }
3340        struct_ser.end()
3341    }
3342}
3343impl<'de> serde::Deserialize<'de> for event_log::EventCreateStreamJobFail {
3344    #[allow(deprecated)]
3345    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3346    where
3347        D: serde::Deserializer<'de>,
3348    {
3349        const FIELDS: &[&str] = &[
3350            "id",
3351            "name",
3352            "definition",
3353            "error",
3354        ];
3355
3356        #[allow(clippy::enum_variant_names)]
3357        enum GeneratedField {
3358            Id,
3359            Name,
3360            Definition,
3361            Error,
3362        }
3363        impl<'de> serde::Deserialize<'de> for GeneratedField {
3364            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3365            where
3366                D: serde::Deserializer<'de>,
3367            {
3368                struct GeneratedVisitor;
3369
3370                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3371                    type Value = GeneratedField;
3372
3373                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3374                        write!(formatter, "expected one of: {:?}", &FIELDS)
3375                    }
3376
3377                    #[allow(unused_variables)]
3378                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3379                    where
3380                        E: serde::de::Error,
3381                    {
3382                        match value {
3383                            "id" => Ok(GeneratedField::Id),
3384                            "name" => Ok(GeneratedField::Name),
3385                            "definition" => Ok(GeneratedField::Definition),
3386                            "error" => Ok(GeneratedField::Error),
3387                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3388                        }
3389                    }
3390                }
3391                deserializer.deserialize_identifier(GeneratedVisitor)
3392            }
3393        }
3394        struct GeneratedVisitor;
3395        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3396            type Value = event_log::EventCreateStreamJobFail;
3397
3398            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3399                formatter.write_str("struct meta.EventLog.EventCreateStreamJobFail")
3400            }
3401
3402            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventCreateStreamJobFail, V::Error>
3403                where
3404                    V: serde::de::MapAccess<'de>,
3405            {
3406                let mut id__ = None;
3407                let mut name__ = None;
3408                let mut definition__ = None;
3409                let mut error__ = None;
3410                while let Some(k) = map_.next_key()? {
3411                    match k {
3412                        GeneratedField::Id => {
3413                            if id__.is_some() {
3414                                return Err(serde::de::Error::duplicate_field("id"));
3415                            }
3416                            id__ = 
3417                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3418                            ;
3419                        }
3420                        GeneratedField::Name => {
3421                            if name__.is_some() {
3422                                return Err(serde::de::Error::duplicate_field("name"));
3423                            }
3424                            name__ = Some(map_.next_value()?);
3425                        }
3426                        GeneratedField::Definition => {
3427                            if definition__.is_some() {
3428                                return Err(serde::de::Error::duplicate_field("definition"));
3429                            }
3430                            definition__ = Some(map_.next_value()?);
3431                        }
3432                        GeneratedField::Error => {
3433                            if error__.is_some() {
3434                                return Err(serde::de::Error::duplicate_field("error"));
3435                            }
3436                            error__ = Some(map_.next_value()?);
3437                        }
3438                    }
3439                }
3440                Ok(event_log::EventCreateStreamJobFail {
3441                    id: id__.unwrap_or_default(),
3442                    name: name__.unwrap_or_default(),
3443                    definition: definition__.unwrap_or_default(),
3444                    error: error__.unwrap_or_default(),
3445                })
3446            }
3447        }
3448        deserializer.deserialize_struct("meta.EventLog.EventCreateStreamJobFail", FIELDS, GeneratedVisitor)
3449    }
3450}
3451impl serde::Serialize for event_log::EventDirtyStreamJobClear {
3452    #[allow(deprecated)]
3453    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3454    where
3455        S: serde::Serializer,
3456    {
3457        use serde::ser::SerializeStruct;
3458        let mut len = 0;
3459        if self.id != 0 {
3460            len += 1;
3461        }
3462        if !self.name.is_empty() {
3463            len += 1;
3464        }
3465        if !self.definition.is_empty() {
3466            len += 1;
3467        }
3468        if !self.error.is_empty() {
3469            len += 1;
3470        }
3471        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventDirtyStreamJobClear", len)?;
3472        if self.id != 0 {
3473            struct_ser.serialize_field("id", &self.id)?;
3474        }
3475        if !self.name.is_empty() {
3476            struct_ser.serialize_field("name", &self.name)?;
3477        }
3478        if !self.definition.is_empty() {
3479            struct_ser.serialize_field("definition", &self.definition)?;
3480        }
3481        if !self.error.is_empty() {
3482            struct_ser.serialize_field("error", &self.error)?;
3483        }
3484        struct_ser.end()
3485    }
3486}
3487impl<'de> serde::Deserialize<'de> for event_log::EventDirtyStreamJobClear {
3488    #[allow(deprecated)]
3489    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3490    where
3491        D: serde::Deserializer<'de>,
3492    {
3493        const FIELDS: &[&str] = &[
3494            "id",
3495            "name",
3496            "definition",
3497            "error",
3498        ];
3499
3500        #[allow(clippy::enum_variant_names)]
3501        enum GeneratedField {
3502            Id,
3503            Name,
3504            Definition,
3505            Error,
3506        }
3507        impl<'de> serde::Deserialize<'de> for GeneratedField {
3508            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3509            where
3510                D: serde::Deserializer<'de>,
3511            {
3512                struct GeneratedVisitor;
3513
3514                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3515                    type Value = GeneratedField;
3516
3517                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3518                        write!(formatter, "expected one of: {:?}", &FIELDS)
3519                    }
3520
3521                    #[allow(unused_variables)]
3522                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3523                    where
3524                        E: serde::de::Error,
3525                    {
3526                        match value {
3527                            "id" => Ok(GeneratedField::Id),
3528                            "name" => Ok(GeneratedField::Name),
3529                            "definition" => Ok(GeneratedField::Definition),
3530                            "error" => Ok(GeneratedField::Error),
3531                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3532                        }
3533                    }
3534                }
3535                deserializer.deserialize_identifier(GeneratedVisitor)
3536            }
3537        }
3538        struct GeneratedVisitor;
3539        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3540            type Value = event_log::EventDirtyStreamJobClear;
3541
3542            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3543                formatter.write_str("struct meta.EventLog.EventDirtyStreamJobClear")
3544            }
3545
3546            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventDirtyStreamJobClear, V::Error>
3547                where
3548                    V: serde::de::MapAccess<'de>,
3549            {
3550                let mut id__ = None;
3551                let mut name__ = None;
3552                let mut definition__ = None;
3553                let mut error__ = None;
3554                while let Some(k) = map_.next_key()? {
3555                    match k {
3556                        GeneratedField::Id => {
3557                            if id__.is_some() {
3558                                return Err(serde::de::Error::duplicate_field("id"));
3559                            }
3560                            id__ = 
3561                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3562                            ;
3563                        }
3564                        GeneratedField::Name => {
3565                            if name__.is_some() {
3566                                return Err(serde::de::Error::duplicate_field("name"));
3567                            }
3568                            name__ = Some(map_.next_value()?);
3569                        }
3570                        GeneratedField::Definition => {
3571                            if definition__.is_some() {
3572                                return Err(serde::de::Error::duplicate_field("definition"));
3573                            }
3574                            definition__ = Some(map_.next_value()?);
3575                        }
3576                        GeneratedField::Error => {
3577                            if error__.is_some() {
3578                                return Err(serde::de::Error::duplicate_field("error"));
3579                            }
3580                            error__ = Some(map_.next_value()?);
3581                        }
3582                    }
3583                }
3584                Ok(event_log::EventDirtyStreamJobClear {
3585                    id: id__.unwrap_or_default(),
3586                    name: name__.unwrap_or_default(),
3587                    definition: definition__.unwrap_or_default(),
3588                    error: error__.unwrap_or_default(),
3589                })
3590            }
3591        }
3592        deserializer.deserialize_struct("meta.EventLog.EventDirtyStreamJobClear", FIELDS, GeneratedVisitor)
3593    }
3594}
3595impl serde::Serialize for event_log::EventInjectBarrierFail {
3596    #[allow(deprecated)]
3597    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3598    where
3599        S: serde::Serializer,
3600    {
3601        use serde::ser::SerializeStruct;
3602        let mut len = 0;
3603        if self.prev_epoch != 0 {
3604            len += 1;
3605        }
3606        if self.cur_epoch != 0 {
3607            len += 1;
3608        }
3609        if !self.error.is_empty() {
3610            len += 1;
3611        }
3612        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventInjectBarrierFail", len)?;
3613        if self.prev_epoch != 0 {
3614            #[allow(clippy::needless_borrow)]
3615            #[allow(clippy::needless_borrows_for_generic_args)]
3616            struct_ser.serialize_field("prevEpoch", ToString::to_string(&self.prev_epoch).as_str())?;
3617        }
3618        if self.cur_epoch != 0 {
3619            #[allow(clippy::needless_borrow)]
3620            #[allow(clippy::needless_borrows_for_generic_args)]
3621            struct_ser.serialize_field("curEpoch", ToString::to_string(&self.cur_epoch).as_str())?;
3622        }
3623        if !self.error.is_empty() {
3624            struct_ser.serialize_field("error", &self.error)?;
3625        }
3626        struct_ser.end()
3627    }
3628}
3629impl<'de> serde::Deserialize<'de> for event_log::EventInjectBarrierFail {
3630    #[allow(deprecated)]
3631    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3632    where
3633        D: serde::Deserializer<'de>,
3634    {
3635        const FIELDS: &[&str] = &[
3636            "prev_epoch",
3637            "prevEpoch",
3638            "cur_epoch",
3639            "curEpoch",
3640            "error",
3641        ];
3642
3643        #[allow(clippy::enum_variant_names)]
3644        enum GeneratedField {
3645            PrevEpoch,
3646            CurEpoch,
3647            Error,
3648        }
3649        impl<'de> serde::Deserialize<'de> for GeneratedField {
3650            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3651            where
3652                D: serde::Deserializer<'de>,
3653            {
3654                struct GeneratedVisitor;
3655
3656                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3657                    type Value = GeneratedField;
3658
3659                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3660                        write!(formatter, "expected one of: {:?}", &FIELDS)
3661                    }
3662
3663                    #[allow(unused_variables)]
3664                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3665                    where
3666                        E: serde::de::Error,
3667                    {
3668                        match value {
3669                            "prevEpoch" | "prev_epoch" => Ok(GeneratedField::PrevEpoch),
3670                            "curEpoch" | "cur_epoch" => Ok(GeneratedField::CurEpoch),
3671                            "error" => Ok(GeneratedField::Error),
3672                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3673                        }
3674                    }
3675                }
3676                deserializer.deserialize_identifier(GeneratedVisitor)
3677            }
3678        }
3679        struct GeneratedVisitor;
3680        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3681            type Value = event_log::EventInjectBarrierFail;
3682
3683            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3684                formatter.write_str("struct meta.EventLog.EventInjectBarrierFail")
3685            }
3686
3687            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventInjectBarrierFail, V::Error>
3688                where
3689                    V: serde::de::MapAccess<'de>,
3690            {
3691                let mut prev_epoch__ = None;
3692                let mut cur_epoch__ = None;
3693                let mut error__ = None;
3694                while let Some(k) = map_.next_key()? {
3695                    match k {
3696                        GeneratedField::PrevEpoch => {
3697                            if prev_epoch__.is_some() {
3698                                return Err(serde::de::Error::duplicate_field("prevEpoch"));
3699                            }
3700                            prev_epoch__ = 
3701                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3702                            ;
3703                        }
3704                        GeneratedField::CurEpoch => {
3705                            if cur_epoch__.is_some() {
3706                                return Err(serde::de::Error::duplicate_field("curEpoch"));
3707                            }
3708                            cur_epoch__ = 
3709                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3710                            ;
3711                        }
3712                        GeneratedField::Error => {
3713                            if error__.is_some() {
3714                                return Err(serde::de::Error::duplicate_field("error"));
3715                            }
3716                            error__ = Some(map_.next_value()?);
3717                        }
3718                    }
3719                }
3720                Ok(event_log::EventInjectBarrierFail {
3721                    prev_epoch: prev_epoch__.unwrap_or_default(),
3722                    cur_epoch: cur_epoch__.unwrap_or_default(),
3723                    error: error__.unwrap_or_default(),
3724                })
3725            }
3726        }
3727        deserializer.deserialize_struct("meta.EventLog.EventInjectBarrierFail", FIELDS, GeneratedVisitor)
3728    }
3729}
3730impl serde::Serialize for event_log::EventMetaNodeStart {
3731    #[allow(deprecated)]
3732    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3733    where
3734        S: serde::Serializer,
3735    {
3736        use serde::ser::SerializeStruct;
3737        let mut len = 0;
3738        if !self.advertise_addr.is_empty() {
3739            len += 1;
3740        }
3741        if !self.listen_addr.is_empty() {
3742            len += 1;
3743        }
3744        if !self.opts.is_empty() {
3745            len += 1;
3746        }
3747        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventMetaNodeStart", len)?;
3748        if !self.advertise_addr.is_empty() {
3749            struct_ser.serialize_field("advertiseAddr", &self.advertise_addr)?;
3750        }
3751        if !self.listen_addr.is_empty() {
3752            struct_ser.serialize_field("listenAddr", &self.listen_addr)?;
3753        }
3754        if !self.opts.is_empty() {
3755            struct_ser.serialize_field("opts", &self.opts)?;
3756        }
3757        struct_ser.end()
3758    }
3759}
3760impl<'de> serde::Deserialize<'de> for event_log::EventMetaNodeStart {
3761    #[allow(deprecated)]
3762    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3763    where
3764        D: serde::Deserializer<'de>,
3765    {
3766        const FIELDS: &[&str] = &[
3767            "advertise_addr",
3768            "advertiseAddr",
3769            "listen_addr",
3770            "listenAddr",
3771            "opts",
3772        ];
3773
3774        #[allow(clippy::enum_variant_names)]
3775        enum GeneratedField {
3776            AdvertiseAddr,
3777            ListenAddr,
3778            Opts,
3779        }
3780        impl<'de> serde::Deserialize<'de> for GeneratedField {
3781            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3782            where
3783                D: serde::Deserializer<'de>,
3784            {
3785                struct GeneratedVisitor;
3786
3787                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3788                    type Value = GeneratedField;
3789
3790                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3791                        write!(formatter, "expected one of: {:?}", &FIELDS)
3792                    }
3793
3794                    #[allow(unused_variables)]
3795                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3796                    where
3797                        E: serde::de::Error,
3798                    {
3799                        match value {
3800                            "advertiseAddr" | "advertise_addr" => Ok(GeneratedField::AdvertiseAddr),
3801                            "listenAddr" | "listen_addr" => Ok(GeneratedField::ListenAddr),
3802                            "opts" => Ok(GeneratedField::Opts),
3803                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3804                        }
3805                    }
3806                }
3807                deserializer.deserialize_identifier(GeneratedVisitor)
3808            }
3809        }
3810        struct GeneratedVisitor;
3811        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3812            type Value = event_log::EventMetaNodeStart;
3813
3814            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3815                formatter.write_str("struct meta.EventLog.EventMetaNodeStart")
3816            }
3817
3818            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventMetaNodeStart, V::Error>
3819                where
3820                    V: serde::de::MapAccess<'de>,
3821            {
3822                let mut advertise_addr__ = None;
3823                let mut listen_addr__ = None;
3824                let mut opts__ = None;
3825                while let Some(k) = map_.next_key()? {
3826                    match k {
3827                        GeneratedField::AdvertiseAddr => {
3828                            if advertise_addr__.is_some() {
3829                                return Err(serde::de::Error::duplicate_field("advertiseAddr"));
3830                            }
3831                            advertise_addr__ = Some(map_.next_value()?);
3832                        }
3833                        GeneratedField::ListenAddr => {
3834                            if listen_addr__.is_some() {
3835                                return Err(serde::de::Error::duplicate_field("listenAddr"));
3836                            }
3837                            listen_addr__ = Some(map_.next_value()?);
3838                        }
3839                        GeneratedField::Opts => {
3840                            if opts__.is_some() {
3841                                return Err(serde::de::Error::duplicate_field("opts"));
3842                            }
3843                            opts__ = Some(map_.next_value()?);
3844                        }
3845                    }
3846                }
3847                Ok(event_log::EventMetaNodeStart {
3848                    advertise_addr: advertise_addr__.unwrap_or_default(),
3849                    listen_addr: listen_addr__.unwrap_or_default(),
3850                    opts: opts__.unwrap_or_default(),
3851                })
3852            }
3853        }
3854        deserializer.deserialize_struct("meta.EventLog.EventMetaNodeStart", FIELDS, GeneratedVisitor)
3855    }
3856}
3857impl serde::Serialize for event_log::EventRecovery {
3858    #[allow(deprecated)]
3859    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3860    where
3861        S: serde::Serializer,
3862    {
3863        use serde::ser::SerializeStruct;
3864        let mut len = 0;
3865        if self.recovery_event.is_some() {
3866            len += 1;
3867        }
3868        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery", len)?;
3869        if let Some(v) = self.recovery_event.as_ref() {
3870            match v {
3871                event_log::event_recovery::RecoveryEvent::GlobalStart(v) => {
3872                    struct_ser.serialize_field("globalStart", v)?;
3873                }
3874                event_log::event_recovery::RecoveryEvent::GlobalSuccess(v) => {
3875                    struct_ser.serialize_field("globalSuccess", v)?;
3876                }
3877                event_log::event_recovery::RecoveryEvent::GlobalFailure(v) => {
3878                    struct_ser.serialize_field("globalFailure", v)?;
3879                }
3880                event_log::event_recovery::RecoveryEvent::DatabaseStart(v) => {
3881                    struct_ser.serialize_field("databaseStart", v)?;
3882                }
3883                event_log::event_recovery::RecoveryEvent::DatabaseFailure(v) => {
3884                    struct_ser.serialize_field("databaseFailure", v)?;
3885                }
3886                event_log::event_recovery::RecoveryEvent::DatabaseSuccess(v) => {
3887                    struct_ser.serialize_field("databaseSuccess", v)?;
3888                }
3889            }
3890        }
3891        struct_ser.end()
3892    }
3893}
3894impl<'de> serde::Deserialize<'de> for event_log::EventRecovery {
3895    #[allow(deprecated)]
3896    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3897    where
3898        D: serde::Deserializer<'de>,
3899    {
3900        const FIELDS: &[&str] = &[
3901            "global_start",
3902            "globalStart",
3903            "global_success",
3904            "globalSuccess",
3905            "global_failure",
3906            "globalFailure",
3907            "database_start",
3908            "databaseStart",
3909            "database_failure",
3910            "databaseFailure",
3911            "database_success",
3912            "databaseSuccess",
3913        ];
3914
3915        #[allow(clippy::enum_variant_names)]
3916        enum GeneratedField {
3917            GlobalStart,
3918            GlobalSuccess,
3919            GlobalFailure,
3920            DatabaseStart,
3921            DatabaseFailure,
3922            DatabaseSuccess,
3923        }
3924        impl<'de> serde::Deserialize<'de> for GeneratedField {
3925            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3926            where
3927                D: serde::Deserializer<'de>,
3928            {
3929                struct GeneratedVisitor;
3930
3931                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3932                    type Value = GeneratedField;
3933
3934                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3935                        write!(formatter, "expected one of: {:?}", &FIELDS)
3936                    }
3937
3938                    #[allow(unused_variables)]
3939                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3940                    where
3941                        E: serde::de::Error,
3942                    {
3943                        match value {
3944                            "globalStart" | "global_start" => Ok(GeneratedField::GlobalStart),
3945                            "globalSuccess" | "global_success" => Ok(GeneratedField::GlobalSuccess),
3946                            "globalFailure" | "global_failure" => Ok(GeneratedField::GlobalFailure),
3947                            "databaseStart" | "database_start" => Ok(GeneratedField::DatabaseStart),
3948                            "databaseFailure" | "database_failure" => Ok(GeneratedField::DatabaseFailure),
3949                            "databaseSuccess" | "database_success" => Ok(GeneratedField::DatabaseSuccess),
3950                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3951                        }
3952                    }
3953                }
3954                deserializer.deserialize_identifier(GeneratedVisitor)
3955            }
3956        }
3957        struct GeneratedVisitor;
3958        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3959            type Value = event_log::EventRecovery;
3960
3961            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3962                formatter.write_str("struct meta.EventLog.EventRecovery")
3963            }
3964
3965            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventRecovery, V::Error>
3966                where
3967                    V: serde::de::MapAccess<'de>,
3968            {
3969                let mut recovery_event__ = None;
3970                while let Some(k) = map_.next_key()? {
3971                    match k {
3972                        GeneratedField::GlobalStart => {
3973                            if recovery_event__.is_some() {
3974                                return Err(serde::de::Error::duplicate_field("globalStart"));
3975                            }
3976                            recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalStart)
3977;
3978                        }
3979                        GeneratedField::GlobalSuccess => {
3980                            if recovery_event__.is_some() {
3981                                return Err(serde::de::Error::duplicate_field("globalSuccess"));
3982                            }
3983                            recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalSuccess)
3984;
3985                        }
3986                        GeneratedField::GlobalFailure => {
3987                            if recovery_event__.is_some() {
3988                                return Err(serde::de::Error::duplicate_field("globalFailure"));
3989                            }
3990                            recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::GlobalFailure)
3991;
3992                        }
3993                        GeneratedField::DatabaseStart => {
3994                            if recovery_event__.is_some() {
3995                                return Err(serde::de::Error::duplicate_field("databaseStart"));
3996                            }
3997                            recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseStart)
3998;
3999                        }
4000                        GeneratedField::DatabaseFailure => {
4001                            if recovery_event__.is_some() {
4002                                return Err(serde::de::Error::duplicate_field("databaseFailure"));
4003                            }
4004                            recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseFailure)
4005;
4006                        }
4007                        GeneratedField::DatabaseSuccess => {
4008                            if recovery_event__.is_some() {
4009                                return Err(serde::de::Error::duplicate_field("databaseSuccess"));
4010                            }
4011                            recovery_event__ = map_.next_value::<::std::option::Option<_>>()?.map(event_log::event_recovery::RecoveryEvent::DatabaseSuccess)
4012;
4013                        }
4014                    }
4015                }
4016                Ok(event_log::EventRecovery {
4017                    recovery_event: recovery_event__,
4018                })
4019            }
4020        }
4021        deserializer.deserialize_struct("meta.EventLog.EventRecovery", FIELDS, GeneratedVisitor)
4022    }
4023}
4024impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryFailure {
4025    #[allow(deprecated)]
4026    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4027    where
4028        S: serde::Serializer,
4029    {
4030        use serde::ser::SerializeStruct;
4031        let mut len = 0;
4032        if self.database_id != 0 {
4033            len += 1;
4034        }
4035        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", len)?;
4036        if self.database_id != 0 {
4037            struct_ser.serialize_field("databaseId", &self.database_id)?;
4038        }
4039        struct_ser.end()
4040    }
4041}
4042impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryFailure {
4043    #[allow(deprecated)]
4044    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4045    where
4046        D: serde::Deserializer<'de>,
4047    {
4048        const FIELDS: &[&str] = &[
4049            "database_id",
4050            "databaseId",
4051        ];
4052
4053        #[allow(clippy::enum_variant_names)]
4054        enum GeneratedField {
4055            DatabaseId,
4056        }
4057        impl<'de> serde::Deserialize<'de> for GeneratedField {
4058            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4059            where
4060                D: serde::Deserializer<'de>,
4061            {
4062                struct GeneratedVisitor;
4063
4064                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4065                    type Value = GeneratedField;
4066
4067                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4068                        write!(formatter, "expected one of: {:?}", &FIELDS)
4069                    }
4070
4071                    #[allow(unused_variables)]
4072                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4073                    where
4074                        E: serde::de::Error,
4075                    {
4076                        match value {
4077                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4078                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4079                        }
4080                    }
4081                }
4082                deserializer.deserialize_identifier(GeneratedVisitor)
4083            }
4084        }
4085        struct GeneratedVisitor;
4086        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4087            type Value = event_log::event_recovery::DatabaseRecoveryFailure;
4088
4089            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4090                formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryFailure")
4091            }
4092
4093            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryFailure, V::Error>
4094                where
4095                    V: serde::de::MapAccess<'de>,
4096            {
4097                let mut database_id__ = None;
4098                while let Some(k) = map_.next_key()? {
4099                    match k {
4100                        GeneratedField::DatabaseId => {
4101                            if database_id__.is_some() {
4102                                return Err(serde::de::Error::duplicate_field("databaseId"));
4103                            }
4104                            database_id__ = 
4105                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4106                            ;
4107                        }
4108                    }
4109                }
4110                Ok(event_log::event_recovery::DatabaseRecoveryFailure {
4111                    database_id: database_id__.unwrap_or_default(),
4112                })
4113            }
4114        }
4115        deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryFailure", FIELDS, GeneratedVisitor)
4116    }
4117}
4118impl serde::Serialize for event_log::event_recovery::DatabaseRecoveryStart {
4119    #[allow(deprecated)]
4120    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4121    where
4122        S: serde::Serializer,
4123    {
4124        use serde::ser::SerializeStruct;
4125        let mut len = 0;
4126        if self.database_id != 0 {
4127            len += 1;
4128        }
4129        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", len)?;
4130        if self.database_id != 0 {
4131            struct_ser.serialize_field("databaseId", &self.database_id)?;
4132        }
4133        struct_ser.end()
4134    }
4135}
4136impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoveryStart {
4137    #[allow(deprecated)]
4138    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4139    where
4140        D: serde::Deserializer<'de>,
4141    {
4142        const FIELDS: &[&str] = &[
4143            "database_id",
4144            "databaseId",
4145        ];
4146
4147        #[allow(clippy::enum_variant_names)]
4148        enum GeneratedField {
4149            DatabaseId,
4150        }
4151        impl<'de> serde::Deserialize<'de> for GeneratedField {
4152            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4153            where
4154                D: serde::Deserializer<'de>,
4155            {
4156                struct GeneratedVisitor;
4157
4158                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4159                    type Value = GeneratedField;
4160
4161                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4162                        write!(formatter, "expected one of: {:?}", &FIELDS)
4163                    }
4164
4165                    #[allow(unused_variables)]
4166                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4167                    where
4168                        E: serde::de::Error,
4169                    {
4170                        match value {
4171                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4172                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4173                        }
4174                    }
4175                }
4176                deserializer.deserialize_identifier(GeneratedVisitor)
4177            }
4178        }
4179        struct GeneratedVisitor;
4180        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4181            type Value = event_log::event_recovery::DatabaseRecoveryStart;
4182
4183            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4184                formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoveryStart")
4185            }
4186
4187            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoveryStart, V::Error>
4188                where
4189                    V: serde::de::MapAccess<'de>,
4190            {
4191                let mut database_id__ = None;
4192                while let Some(k) = map_.next_key()? {
4193                    match k {
4194                        GeneratedField::DatabaseId => {
4195                            if database_id__.is_some() {
4196                                return Err(serde::de::Error::duplicate_field("databaseId"));
4197                            }
4198                            database_id__ = 
4199                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4200                            ;
4201                        }
4202                    }
4203                }
4204                Ok(event_log::event_recovery::DatabaseRecoveryStart {
4205                    database_id: database_id__.unwrap_or_default(),
4206                })
4207            }
4208        }
4209        deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoveryStart", FIELDS, GeneratedVisitor)
4210    }
4211}
4212impl serde::Serialize for event_log::event_recovery::DatabaseRecoverySuccess {
4213    #[allow(deprecated)]
4214    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4215    where
4216        S: serde::Serializer,
4217    {
4218        use serde::ser::SerializeStruct;
4219        let mut len = 0;
4220        if self.database_id != 0 {
4221            len += 1;
4222        }
4223        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", len)?;
4224        if self.database_id != 0 {
4225            struct_ser.serialize_field("databaseId", &self.database_id)?;
4226        }
4227        struct_ser.end()
4228    }
4229}
4230impl<'de> serde::Deserialize<'de> for event_log::event_recovery::DatabaseRecoverySuccess {
4231    #[allow(deprecated)]
4232    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4233    where
4234        D: serde::Deserializer<'de>,
4235    {
4236        const FIELDS: &[&str] = &[
4237            "database_id",
4238            "databaseId",
4239        ];
4240
4241        #[allow(clippy::enum_variant_names)]
4242        enum GeneratedField {
4243            DatabaseId,
4244        }
4245        impl<'de> serde::Deserialize<'de> for GeneratedField {
4246            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4247            where
4248                D: serde::Deserializer<'de>,
4249            {
4250                struct GeneratedVisitor;
4251
4252                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4253                    type Value = GeneratedField;
4254
4255                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4256                        write!(formatter, "expected one of: {:?}", &FIELDS)
4257                    }
4258
4259                    #[allow(unused_variables)]
4260                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4261                    where
4262                        E: serde::de::Error,
4263                    {
4264                        match value {
4265                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
4266                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4267                        }
4268                    }
4269                }
4270                deserializer.deserialize_identifier(GeneratedVisitor)
4271            }
4272        }
4273        struct GeneratedVisitor;
4274        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4275            type Value = event_log::event_recovery::DatabaseRecoverySuccess;
4276
4277            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4278                formatter.write_str("struct meta.EventLog.EventRecovery.DatabaseRecoverySuccess")
4279            }
4280
4281            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::DatabaseRecoverySuccess, V::Error>
4282                where
4283                    V: serde::de::MapAccess<'de>,
4284            {
4285                let mut database_id__ = None;
4286                while let Some(k) = map_.next_key()? {
4287                    match k {
4288                        GeneratedField::DatabaseId => {
4289                            if database_id__.is_some() {
4290                                return Err(serde::de::Error::duplicate_field("databaseId"));
4291                            }
4292                            database_id__ = 
4293                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4294                            ;
4295                        }
4296                    }
4297                }
4298                Ok(event_log::event_recovery::DatabaseRecoverySuccess {
4299                    database_id: database_id__.unwrap_or_default(),
4300                })
4301            }
4302        }
4303        deserializer.deserialize_struct("meta.EventLog.EventRecovery.DatabaseRecoverySuccess", FIELDS, GeneratedVisitor)
4304    }
4305}
4306impl serde::Serialize for event_log::event_recovery::GlobalRecoveryFailure {
4307    #[allow(deprecated)]
4308    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4309    where
4310        S: serde::Serializer,
4311    {
4312        use serde::ser::SerializeStruct;
4313        let mut len = 0;
4314        if !self.reason.is_empty() {
4315            len += 1;
4316        }
4317        if !self.error.is_empty() {
4318            len += 1;
4319        }
4320        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", len)?;
4321        if !self.reason.is_empty() {
4322            struct_ser.serialize_field("reason", &self.reason)?;
4323        }
4324        if !self.error.is_empty() {
4325            struct_ser.serialize_field("error", &self.error)?;
4326        }
4327        struct_ser.end()
4328    }
4329}
4330impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryFailure {
4331    #[allow(deprecated)]
4332    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4333    where
4334        D: serde::Deserializer<'de>,
4335    {
4336        const FIELDS: &[&str] = &[
4337            "reason",
4338            "error",
4339        ];
4340
4341        #[allow(clippy::enum_variant_names)]
4342        enum GeneratedField {
4343            Reason,
4344            Error,
4345        }
4346        impl<'de> serde::Deserialize<'de> for GeneratedField {
4347            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4348            where
4349                D: serde::Deserializer<'de>,
4350            {
4351                struct GeneratedVisitor;
4352
4353                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4354                    type Value = GeneratedField;
4355
4356                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4357                        write!(formatter, "expected one of: {:?}", &FIELDS)
4358                    }
4359
4360                    #[allow(unused_variables)]
4361                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4362                    where
4363                        E: serde::de::Error,
4364                    {
4365                        match value {
4366                            "reason" => Ok(GeneratedField::Reason),
4367                            "error" => Ok(GeneratedField::Error),
4368                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4369                        }
4370                    }
4371                }
4372                deserializer.deserialize_identifier(GeneratedVisitor)
4373            }
4374        }
4375        struct GeneratedVisitor;
4376        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4377            type Value = event_log::event_recovery::GlobalRecoveryFailure;
4378
4379            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4380                formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryFailure")
4381            }
4382
4383            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryFailure, V::Error>
4384                where
4385                    V: serde::de::MapAccess<'de>,
4386            {
4387                let mut reason__ = None;
4388                let mut error__ = None;
4389                while let Some(k) = map_.next_key()? {
4390                    match k {
4391                        GeneratedField::Reason => {
4392                            if reason__.is_some() {
4393                                return Err(serde::de::Error::duplicate_field("reason"));
4394                            }
4395                            reason__ = Some(map_.next_value()?);
4396                        }
4397                        GeneratedField::Error => {
4398                            if error__.is_some() {
4399                                return Err(serde::de::Error::duplicate_field("error"));
4400                            }
4401                            error__ = Some(map_.next_value()?);
4402                        }
4403                    }
4404                }
4405                Ok(event_log::event_recovery::GlobalRecoveryFailure {
4406                    reason: reason__.unwrap_or_default(),
4407                    error: error__.unwrap_or_default(),
4408                })
4409            }
4410        }
4411        deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryFailure", FIELDS, GeneratedVisitor)
4412    }
4413}
4414impl serde::Serialize for event_log::event_recovery::GlobalRecoveryStart {
4415    #[allow(deprecated)]
4416    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4417    where
4418        S: serde::Serializer,
4419    {
4420        use serde::ser::SerializeStruct;
4421        let mut len = 0;
4422        if !self.reason.is_empty() {
4423            len += 1;
4424        }
4425        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", len)?;
4426        if !self.reason.is_empty() {
4427            struct_ser.serialize_field("reason", &self.reason)?;
4428        }
4429        struct_ser.end()
4430    }
4431}
4432impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoveryStart {
4433    #[allow(deprecated)]
4434    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4435    where
4436        D: serde::Deserializer<'de>,
4437    {
4438        const FIELDS: &[&str] = &[
4439            "reason",
4440        ];
4441
4442        #[allow(clippy::enum_variant_names)]
4443        enum GeneratedField {
4444            Reason,
4445        }
4446        impl<'de> serde::Deserialize<'de> for GeneratedField {
4447            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4448            where
4449                D: serde::Deserializer<'de>,
4450            {
4451                struct GeneratedVisitor;
4452
4453                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4454                    type Value = GeneratedField;
4455
4456                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4457                        write!(formatter, "expected one of: {:?}", &FIELDS)
4458                    }
4459
4460                    #[allow(unused_variables)]
4461                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4462                    where
4463                        E: serde::de::Error,
4464                    {
4465                        match value {
4466                            "reason" => Ok(GeneratedField::Reason),
4467                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4468                        }
4469                    }
4470                }
4471                deserializer.deserialize_identifier(GeneratedVisitor)
4472            }
4473        }
4474        struct GeneratedVisitor;
4475        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4476            type Value = event_log::event_recovery::GlobalRecoveryStart;
4477
4478            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4479                formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoveryStart")
4480            }
4481
4482            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoveryStart, V::Error>
4483                where
4484                    V: serde::de::MapAccess<'de>,
4485            {
4486                let mut reason__ = None;
4487                while let Some(k) = map_.next_key()? {
4488                    match k {
4489                        GeneratedField::Reason => {
4490                            if reason__.is_some() {
4491                                return Err(serde::de::Error::duplicate_field("reason"));
4492                            }
4493                            reason__ = Some(map_.next_value()?);
4494                        }
4495                    }
4496                }
4497                Ok(event_log::event_recovery::GlobalRecoveryStart {
4498                    reason: reason__.unwrap_or_default(),
4499                })
4500            }
4501        }
4502        deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoveryStart", FIELDS, GeneratedVisitor)
4503    }
4504}
4505impl serde::Serialize for event_log::event_recovery::GlobalRecoverySuccess {
4506    #[allow(deprecated)]
4507    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4508    where
4509        S: serde::Serializer,
4510    {
4511        use serde::ser::SerializeStruct;
4512        let mut len = 0;
4513        if !self.reason.is_empty() {
4514            len += 1;
4515        }
4516        if self.duration_secs != 0. {
4517            len += 1;
4518        }
4519        if !self.running_database_ids.is_empty() {
4520            len += 1;
4521        }
4522        if !self.recovering_database_ids.is_empty() {
4523            len += 1;
4524        }
4525        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", len)?;
4526        if !self.reason.is_empty() {
4527            struct_ser.serialize_field("reason", &self.reason)?;
4528        }
4529        if self.duration_secs != 0. {
4530            struct_ser.serialize_field("durationSecs", &self.duration_secs)?;
4531        }
4532        if !self.running_database_ids.is_empty() {
4533            struct_ser.serialize_field("runningDatabaseIds", &self.running_database_ids)?;
4534        }
4535        if !self.recovering_database_ids.is_empty() {
4536            struct_ser.serialize_field("recoveringDatabaseIds", &self.recovering_database_ids)?;
4537        }
4538        struct_ser.end()
4539    }
4540}
4541impl<'de> serde::Deserialize<'de> for event_log::event_recovery::GlobalRecoverySuccess {
4542    #[allow(deprecated)]
4543    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4544    where
4545        D: serde::Deserializer<'de>,
4546    {
4547        const FIELDS: &[&str] = &[
4548            "reason",
4549            "duration_secs",
4550            "durationSecs",
4551            "running_database_ids",
4552            "runningDatabaseIds",
4553            "recovering_database_ids",
4554            "recoveringDatabaseIds",
4555        ];
4556
4557        #[allow(clippy::enum_variant_names)]
4558        enum GeneratedField {
4559            Reason,
4560            DurationSecs,
4561            RunningDatabaseIds,
4562            RecoveringDatabaseIds,
4563        }
4564        impl<'de> serde::Deserialize<'de> for GeneratedField {
4565            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4566            where
4567                D: serde::Deserializer<'de>,
4568            {
4569                struct GeneratedVisitor;
4570
4571                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4572                    type Value = GeneratedField;
4573
4574                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4575                        write!(formatter, "expected one of: {:?}", &FIELDS)
4576                    }
4577
4578                    #[allow(unused_variables)]
4579                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4580                    where
4581                        E: serde::de::Error,
4582                    {
4583                        match value {
4584                            "reason" => Ok(GeneratedField::Reason),
4585                            "durationSecs" | "duration_secs" => Ok(GeneratedField::DurationSecs),
4586                            "runningDatabaseIds" | "running_database_ids" => Ok(GeneratedField::RunningDatabaseIds),
4587                            "recoveringDatabaseIds" | "recovering_database_ids" => Ok(GeneratedField::RecoveringDatabaseIds),
4588                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4589                        }
4590                    }
4591                }
4592                deserializer.deserialize_identifier(GeneratedVisitor)
4593            }
4594        }
4595        struct GeneratedVisitor;
4596        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4597            type Value = event_log::event_recovery::GlobalRecoverySuccess;
4598
4599            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4600                formatter.write_str("struct meta.EventLog.EventRecovery.GlobalRecoverySuccess")
4601            }
4602
4603            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::event_recovery::GlobalRecoverySuccess, V::Error>
4604                where
4605                    V: serde::de::MapAccess<'de>,
4606            {
4607                let mut reason__ = None;
4608                let mut duration_secs__ = None;
4609                let mut running_database_ids__ = None;
4610                let mut recovering_database_ids__ = None;
4611                while let Some(k) = map_.next_key()? {
4612                    match k {
4613                        GeneratedField::Reason => {
4614                            if reason__.is_some() {
4615                                return Err(serde::de::Error::duplicate_field("reason"));
4616                            }
4617                            reason__ = Some(map_.next_value()?);
4618                        }
4619                        GeneratedField::DurationSecs => {
4620                            if duration_secs__.is_some() {
4621                                return Err(serde::de::Error::duplicate_field("durationSecs"));
4622                            }
4623                            duration_secs__ = 
4624                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4625                            ;
4626                        }
4627                        GeneratedField::RunningDatabaseIds => {
4628                            if running_database_ids__.is_some() {
4629                                return Err(serde::de::Error::duplicate_field("runningDatabaseIds"));
4630                            }
4631                            running_database_ids__ = 
4632                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4633                                    .into_iter().map(|x| x.0).collect())
4634                            ;
4635                        }
4636                        GeneratedField::RecoveringDatabaseIds => {
4637                            if recovering_database_ids__.is_some() {
4638                                return Err(serde::de::Error::duplicate_field("recoveringDatabaseIds"));
4639                            }
4640                            recovering_database_ids__ = 
4641                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4642                                    .into_iter().map(|x| x.0).collect())
4643                            ;
4644                        }
4645                    }
4646                }
4647                Ok(event_log::event_recovery::GlobalRecoverySuccess {
4648                    reason: reason__.unwrap_or_default(),
4649                    duration_secs: duration_secs__.unwrap_or_default(),
4650                    running_database_ids: running_database_ids__.unwrap_or_default(),
4651                    recovering_database_ids: recovering_database_ids__.unwrap_or_default(),
4652                })
4653            }
4654        }
4655        deserializer.deserialize_struct("meta.EventLog.EventRecovery.GlobalRecoverySuccess", FIELDS, GeneratedVisitor)
4656    }
4657}
4658impl serde::Serialize for event_log::EventSinkFail {
4659    #[allow(deprecated)]
4660    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4661    where
4662        S: serde::Serializer,
4663    {
4664        use serde::ser::SerializeStruct;
4665        let mut len = 0;
4666        if self.sink_id != 0 {
4667            len += 1;
4668        }
4669        if !self.sink_name.is_empty() {
4670            len += 1;
4671        }
4672        if !self.connector.is_empty() {
4673            len += 1;
4674        }
4675        if !self.error.is_empty() {
4676            len += 1;
4677        }
4678        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventSinkFail", len)?;
4679        if self.sink_id != 0 {
4680            struct_ser.serialize_field("sinkId", &self.sink_id)?;
4681        }
4682        if !self.sink_name.is_empty() {
4683            struct_ser.serialize_field("sinkName", &self.sink_name)?;
4684        }
4685        if !self.connector.is_empty() {
4686            struct_ser.serialize_field("connector", &self.connector)?;
4687        }
4688        if !self.error.is_empty() {
4689            struct_ser.serialize_field("error", &self.error)?;
4690        }
4691        struct_ser.end()
4692    }
4693}
4694impl<'de> serde::Deserialize<'de> for event_log::EventSinkFail {
4695    #[allow(deprecated)]
4696    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4697    where
4698        D: serde::Deserializer<'de>,
4699    {
4700        const FIELDS: &[&str] = &[
4701            "sink_id",
4702            "sinkId",
4703            "sink_name",
4704            "sinkName",
4705            "connector",
4706            "error",
4707        ];
4708
4709        #[allow(clippy::enum_variant_names)]
4710        enum GeneratedField {
4711            SinkId,
4712            SinkName,
4713            Connector,
4714            Error,
4715        }
4716        impl<'de> serde::Deserialize<'de> for GeneratedField {
4717            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4718            where
4719                D: serde::Deserializer<'de>,
4720            {
4721                struct GeneratedVisitor;
4722
4723                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4724                    type Value = GeneratedField;
4725
4726                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4727                        write!(formatter, "expected one of: {:?}", &FIELDS)
4728                    }
4729
4730                    #[allow(unused_variables)]
4731                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4732                    where
4733                        E: serde::de::Error,
4734                    {
4735                        match value {
4736                            "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
4737                            "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
4738                            "connector" => Ok(GeneratedField::Connector),
4739                            "error" => Ok(GeneratedField::Error),
4740                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4741                        }
4742                    }
4743                }
4744                deserializer.deserialize_identifier(GeneratedVisitor)
4745            }
4746        }
4747        struct GeneratedVisitor;
4748        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4749            type Value = event_log::EventSinkFail;
4750
4751            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4752                formatter.write_str("struct meta.EventLog.EventSinkFail")
4753            }
4754
4755            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventSinkFail, V::Error>
4756                where
4757                    V: serde::de::MapAccess<'de>,
4758            {
4759                let mut sink_id__ = None;
4760                let mut sink_name__ = None;
4761                let mut connector__ = None;
4762                let mut error__ = None;
4763                while let Some(k) = map_.next_key()? {
4764                    match k {
4765                        GeneratedField::SinkId => {
4766                            if sink_id__.is_some() {
4767                                return Err(serde::de::Error::duplicate_field("sinkId"));
4768                            }
4769                            sink_id__ = 
4770                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4771                            ;
4772                        }
4773                        GeneratedField::SinkName => {
4774                            if sink_name__.is_some() {
4775                                return Err(serde::de::Error::duplicate_field("sinkName"));
4776                            }
4777                            sink_name__ = Some(map_.next_value()?);
4778                        }
4779                        GeneratedField::Connector => {
4780                            if connector__.is_some() {
4781                                return Err(serde::de::Error::duplicate_field("connector"));
4782                            }
4783                            connector__ = Some(map_.next_value()?);
4784                        }
4785                        GeneratedField::Error => {
4786                            if error__.is_some() {
4787                                return Err(serde::de::Error::duplicate_field("error"));
4788                            }
4789                            error__ = Some(map_.next_value()?);
4790                        }
4791                    }
4792                }
4793                Ok(event_log::EventSinkFail {
4794                    sink_id: sink_id__.unwrap_or_default(),
4795                    sink_name: sink_name__.unwrap_or_default(),
4796                    connector: connector__.unwrap_or_default(),
4797                    error: error__.unwrap_or_default(),
4798                })
4799            }
4800        }
4801        deserializer.deserialize_struct("meta.EventLog.EventSinkFail", FIELDS, GeneratedVisitor)
4802    }
4803}
4804impl serde::Serialize for event_log::EventWorkerNodePanic {
4805    #[allow(deprecated)]
4806    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4807    where
4808        S: serde::Serializer,
4809    {
4810        use serde::ser::SerializeStruct;
4811        let mut len = 0;
4812        if self.worker_id != 0 {
4813            len += 1;
4814        }
4815        if self.worker_type != 0 {
4816            len += 1;
4817        }
4818        if self.host_addr.is_some() {
4819            len += 1;
4820        }
4821        if !self.panic_info.is_empty() {
4822            len += 1;
4823        }
4824        let mut struct_ser = serializer.serialize_struct("meta.EventLog.EventWorkerNodePanic", len)?;
4825        if self.worker_id != 0 {
4826            struct_ser.serialize_field("workerId", &self.worker_id)?;
4827        }
4828        if self.worker_type != 0 {
4829            let v = super::common::WorkerType::try_from(self.worker_type)
4830                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.worker_type)))?;
4831            struct_ser.serialize_field("workerType", &v)?;
4832        }
4833        if let Some(v) = self.host_addr.as_ref() {
4834            struct_ser.serialize_field("hostAddr", v)?;
4835        }
4836        if !self.panic_info.is_empty() {
4837            struct_ser.serialize_field("panicInfo", &self.panic_info)?;
4838        }
4839        struct_ser.end()
4840    }
4841}
4842impl<'de> serde::Deserialize<'de> for event_log::EventWorkerNodePanic {
4843    #[allow(deprecated)]
4844    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4845    where
4846        D: serde::Deserializer<'de>,
4847    {
4848        const FIELDS: &[&str] = &[
4849            "worker_id",
4850            "workerId",
4851            "worker_type",
4852            "workerType",
4853            "host_addr",
4854            "hostAddr",
4855            "panic_info",
4856            "panicInfo",
4857        ];
4858
4859        #[allow(clippy::enum_variant_names)]
4860        enum GeneratedField {
4861            WorkerId,
4862            WorkerType,
4863            HostAddr,
4864            PanicInfo,
4865        }
4866        impl<'de> serde::Deserialize<'de> for GeneratedField {
4867            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4868            where
4869                D: serde::Deserializer<'de>,
4870            {
4871                struct GeneratedVisitor;
4872
4873                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4874                    type Value = GeneratedField;
4875
4876                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4877                        write!(formatter, "expected one of: {:?}", &FIELDS)
4878                    }
4879
4880                    #[allow(unused_variables)]
4881                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4882                    where
4883                        E: serde::de::Error,
4884                    {
4885                        match value {
4886                            "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
4887                            "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
4888                            "hostAddr" | "host_addr" => Ok(GeneratedField::HostAddr),
4889                            "panicInfo" | "panic_info" => Ok(GeneratedField::PanicInfo),
4890                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4891                        }
4892                    }
4893                }
4894                deserializer.deserialize_identifier(GeneratedVisitor)
4895            }
4896        }
4897        struct GeneratedVisitor;
4898        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4899            type Value = event_log::EventWorkerNodePanic;
4900
4901            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4902                formatter.write_str("struct meta.EventLog.EventWorkerNodePanic")
4903            }
4904
4905            fn visit_map<V>(self, mut map_: V) -> std::result::Result<event_log::EventWorkerNodePanic, V::Error>
4906                where
4907                    V: serde::de::MapAccess<'de>,
4908            {
4909                let mut worker_id__ = None;
4910                let mut worker_type__ = None;
4911                let mut host_addr__ = None;
4912                let mut panic_info__ = None;
4913                while let Some(k) = map_.next_key()? {
4914                    match k {
4915                        GeneratedField::WorkerId => {
4916                            if worker_id__.is_some() {
4917                                return Err(serde::de::Error::duplicate_field("workerId"));
4918                            }
4919                            worker_id__ = 
4920                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4921                            ;
4922                        }
4923                        GeneratedField::WorkerType => {
4924                            if worker_type__.is_some() {
4925                                return Err(serde::de::Error::duplicate_field("workerType"));
4926                            }
4927                            worker_type__ = Some(map_.next_value::<super::common::WorkerType>()? as i32);
4928                        }
4929                        GeneratedField::HostAddr => {
4930                            if host_addr__.is_some() {
4931                                return Err(serde::de::Error::duplicate_field("hostAddr"));
4932                            }
4933                            host_addr__ = map_.next_value()?;
4934                        }
4935                        GeneratedField::PanicInfo => {
4936                            if panic_info__.is_some() {
4937                                return Err(serde::de::Error::duplicate_field("panicInfo"));
4938                            }
4939                            panic_info__ = Some(map_.next_value()?);
4940                        }
4941                    }
4942                }
4943                Ok(event_log::EventWorkerNodePanic {
4944                    worker_id: worker_id__.unwrap_or_default(),
4945                    worker_type: worker_type__.unwrap_or_default(),
4946                    host_addr: host_addr__,
4947                    panic_info: panic_info__.unwrap_or_default(),
4948                })
4949            }
4950        }
4951        deserializer.deserialize_struct("meta.EventLog.EventWorkerNodePanic", FIELDS, GeneratedVisitor)
4952    }
4953}
4954impl serde::Serialize for FlushRequest {
4955    #[allow(deprecated)]
4956    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4957    where
4958        S: serde::Serializer,
4959    {
4960        use serde::ser::SerializeStruct;
4961        let mut len = 0;
4962        if self.database_id != 0 {
4963            len += 1;
4964        }
4965        let mut struct_ser = serializer.serialize_struct("meta.FlushRequest", len)?;
4966        if self.database_id != 0 {
4967            struct_ser.serialize_field("databaseId", &self.database_id)?;
4968        }
4969        struct_ser.end()
4970    }
4971}
4972impl<'de> serde::Deserialize<'de> for FlushRequest {
4973    #[allow(deprecated)]
4974    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4975    where
4976        D: serde::Deserializer<'de>,
4977    {
4978        const FIELDS: &[&str] = &[
4979            "database_id",
4980            "databaseId",
4981        ];
4982
4983        #[allow(clippy::enum_variant_names)]
4984        enum GeneratedField {
4985            DatabaseId,
4986        }
4987        impl<'de> serde::Deserialize<'de> for GeneratedField {
4988            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4989            where
4990                D: serde::Deserializer<'de>,
4991            {
4992                struct GeneratedVisitor;
4993
4994                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4995                    type Value = GeneratedField;
4996
4997                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4998                        write!(formatter, "expected one of: {:?}", &FIELDS)
4999                    }
5000
5001                    #[allow(unused_variables)]
5002                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5003                    where
5004                        E: serde::de::Error,
5005                    {
5006                        match value {
5007                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
5008                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5009                        }
5010                    }
5011                }
5012                deserializer.deserialize_identifier(GeneratedVisitor)
5013            }
5014        }
5015        struct GeneratedVisitor;
5016        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5017            type Value = FlushRequest;
5018
5019            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5020                formatter.write_str("struct meta.FlushRequest")
5021            }
5022
5023            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushRequest, V::Error>
5024                where
5025                    V: serde::de::MapAccess<'de>,
5026            {
5027                let mut database_id__ = None;
5028                while let Some(k) = map_.next_key()? {
5029                    match k {
5030                        GeneratedField::DatabaseId => {
5031                            if database_id__.is_some() {
5032                                return Err(serde::de::Error::duplicate_field("databaseId"));
5033                            }
5034                            database_id__ = 
5035                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5036                            ;
5037                        }
5038                    }
5039                }
5040                Ok(FlushRequest {
5041                    database_id: database_id__.unwrap_or_default(),
5042                })
5043            }
5044        }
5045        deserializer.deserialize_struct("meta.FlushRequest", FIELDS, GeneratedVisitor)
5046    }
5047}
5048impl serde::Serialize for FlushResponse {
5049    #[allow(deprecated)]
5050    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5051    where
5052        S: serde::Serializer,
5053    {
5054        use serde::ser::SerializeStruct;
5055        let mut len = 0;
5056        if self.status.is_some() {
5057            len += 1;
5058        }
5059        if self.hummock_version_id != 0 {
5060            len += 1;
5061        }
5062        let mut struct_ser = serializer.serialize_struct("meta.FlushResponse", len)?;
5063        if let Some(v) = self.status.as_ref() {
5064            struct_ser.serialize_field("status", v)?;
5065        }
5066        if self.hummock_version_id != 0 {
5067            #[allow(clippy::needless_borrow)]
5068            #[allow(clippy::needless_borrows_for_generic_args)]
5069            struct_ser.serialize_field("hummockVersionId", ToString::to_string(&self.hummock_version_id).as_str())?;
5070        }
5071        struct_ser.end()
5072    }
5073}
5074impl<'de> serde::Deserialize<'de> for FlushResponse {
5075    #[allow(deprecated)]
5076    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5077    where
5078        D: serde::Deserializer<'de>,
5079    {
5080        const FIELDS: &[&str] = &[
5081            "status",
5082            "hummock_version_id",
5083            "hummockVersionId",
5084        ];
5085
5086        #[allow(clippy::enum_variant_names)]
5087        enum GeneratedField {
5088            Status,
5089            HummockVersionId,
5090        }
5091        impl<'de> serde::Deserialize<'de> for GeneratedField {
5092            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5093            where
5094                D: serde::Deserializer<'de>,
5095            {
5096                struct GeneratedVisitor;
5097
5098                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5099                    type Value = GeneratedField;
5100
5101                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5102                        write!(formatter, "expected one of: {:?}", &FIELDS)
5103                    }
5104
5105                    #[allow(unused_variables)]
5106                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5107                    where
5108                        E: serde::de::Error,
5109                    {
5110                        match value {
5111                            "status" => Ok(GeneratedField::Status),
5112                            "hummockVersionId" | "hummock_version_id" => Ok(GeneratedField::HummockVersionId),
5113                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5114                        }
5115                    }
5116                }
5117                deserializer.deserialize_identifier(GeneratedVisitor)
5118            }
5119        }
5120        struct GeneratedVisitor;
5121        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5122            type Value = FlushResponse;
5123
5124            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5125                formatter.write_str("struct meta.FlushResponse")
5126            }
5127
5128            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FlushResponse, V::Error>
5129                where
5130                    V: serde::de::MapAccess<'de>,
5131            {
5132                let mut status__ = None;
5133                let mut hummock_version_id__ = None;
5134                while let Some(k) = map_.next_key()? {
5135                    match k {
5136                        GeneratedField::Status => {
5137                            if status__.is_some() {
5138                                return Err(serde::de::Error::duplicate_field("status"));
5139                            }
5140                            status__ = map_.next_value()?;
5141                        }
5142                        GeneratedField::HummockVersionId => {
5143                            if hummock_version_id__.is_some() {
5144                                return Err(serde::de::Error::duplicate_field("hummockVersionId"));
5145                            }
5146                            hummock_version_id__ = 
5147                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5148                            ;
5149                        }
5150                    }
5151                }
5152                Ok(FlushResponse {
5153                    status: status__,
5154                    hummock_version_id: hummock_version_id__.unwrap_or_default(),
5155                })
5156            }
5157        }
5158        deserializer.deserialize_struct("meta.FlushResponse", FIELDS, GeneratedVisitor)
5159    }
5160}
5161impl serde::Serialize for FragmentDistribution {
5162    #[allow(deprecated)]
5163    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5164    where
5165        S: serde::Serializer,
5166    {
5167        use serde::ser::SerializeStruct;
5168        let mut len = 0;
5169        if self.fragment_id != 0 {
5170            len += 1;
5171        }
5172        if self.table_id != 0 {
5173            len += 1;
5174        }
5175        if self.distribution_type != 0 {
5176            len += 1;
5177        }
5178        if !self.state_table_ids.is_empty() {
5179            len += 1;
5180        }
5181        if !self.upstream_fragment_ids.is_empty() {
5182            len += 1;
5183        }
5184        if self.fragment_type_mask != 0 {
5185            len += 1;
5186        }
5187        if self.parallelism != 0 {
5188            len += 1;
5189        }
5190        if self.vnode_count != 0 {
5191            len += 1;
5192        }
5193        if self.node.is_some() {
5194            len += 1;
5195        }
5196        let mut struct_ser = serializer.serialize_struct("meta.FragmentDistribution", len)?;
5197        if self.fragment_id != 0 {
5198            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5199        }
5200        if self.table_id != 0 {
5201            struct_ser.serialize_field("tableId", &self.table_id)?;
5202        }
5203        if self.distribution_type != 0 {
5204            let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
5205                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
5206            struct_ser.serialize_field("distributionType", &v)?;
5207        }
5208        if !self.state_table_ids.is_empty() {
5209            struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
5210        }
5211        if !self.upstream_fragment_ids.is_empty() {
5212            struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
5213        }
5214        if self.fragment_type_mask != 0 {
5215            struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
5216        }
5217        if self.parallelism != 0 {
5218            struct_ser.serialize_field("parallelism", &self.parallelism)?;
5219        }
5220        if self.vnode_count != 0 {
5221            struct_ser.serialize_field("vnodeCount", &self.vnode_count)?;
5222        }
5223        if let Some(v) = self.node.as_ref() {
5224            struct_ser.serialize_field("node", v)?;
5225        }
5226        struct_ser.end()
5227    }
5228}
5229impl<'de> serde::Deserialize<'de> for FragmentDistribution {
5230    #[allow(deprecated)]
5231    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5232    where
5233        D: serde::Deserializer<'de>,
5234    {
5235        const FIELDS: &[&str] = &[
5236            "fragment_id",
5237            "fragmentId",
5238            "table_id",
5239            "tableId",
5240            "distribution_type",
5241            "distributionType",
5242            "state_table_ids",
5243            "stateTableIds",
5244            "upstream_fragment_ids",
5245            "upstreamFragmentIds",
5246            "fragment_type_mask",
5247            "fragmentTypeMask",
5248            "parallelism",
5249            "vnode_count",
5250            "vnodeCount",
5251            "node",
5252        ];
5253
5254        #[allow(clippy::enum_variant_names)]
5255        enum GeneratedField {
5256            FragmentId,
5257            TableId,
5258            DistributionType,
5259            StateTableIds,
5260            UpstreamFragmentIds,
5261            FragmentTypeMask,
5262            Parallelism,
5263            VnodeCount,
5264            Node,
5265        }
5266        impl<'de> serde::Deserialize<'de> for GeneratedField {
5267            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5268            where
5269                D: serde::Deserializer<'de>,
5270            {
5271                struct GeneratedVisitor;
5272
5273                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5274                    type Value = GeneratedField;
5275
5276                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5277                        write!(formatter, "expected one of: {:?}", &FIELDS)
5278                    }
5279
5280                    #[allow(unused_variables)]
5281                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5282                    where
5283                        E: serde::de::Error,
5284                    {
5285                        match value {
5286                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5287                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
5288                            "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
5289                            "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
5290                            "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
5291                            "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
5292                            "parallelism" => Ok(GeneratedField::Parallelism),
5293                            "vnodeCount" | "vnode_count" => Ok(GeneratedField::VnodeCount),
5294                            "node" => Ok(GeneratedField::Node),
5295                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5296                        }
5297                    }
5298                }
5299                deserializer.deserialize_identifier(GeneratedVisitor)
5300            }
5301        }
5302        struct GeneratedVisitor;
5303        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5304            type Value = FragmentDistribution;
5305
5306            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5307                formatter.write_str("struct meta.FragmentDistribution")
5308            }
5309
5310            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentDistribution, V::Error>
5311                where
5312                    V: serde::de::MapAccess<'de>,
5313            {
5314                let mut fragment_id__ = None;
5315                let mut table_id__ = None;
5316                let mut distribution_type__ = None;
5317                let mut state_table_ids__ = None;
5318                let mut upstream_fragment_ids__ = None;
5319                let mut fragment_type_mask__ = None;
5320                let mut parallelism__ = None;
5321                let mut vnode_count__ = None;
5322                let mut node__ = None;
5323                while let Some(k) = map_.next_key()? {
5324                    match k {
5325                        GeneratedField::FragmentId => {
5326                            if fragment_id__.is_some() {
5327                                return Err(serde::de::Error::duplicate_field("fragmentId"));
5328                            }
5329                            fragment_id__ = 
5330                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5331                            ;
5332                        }
5333                        GeneratedField::TableId => {
5334                            if table_id__.is_some() {
5335                                return Err(serde::de::Error::duplicate_field("tableId"));
5336                            }
5337                            table_id__ = 
5338                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5339                            ;
5340                        }
5341                        GeneratedField::DistributionType => {
5342                            if distribution_type__.is_some() {
5343                                return Err(serde::de::Error::duplicate_field("distributionType"));
5344                            }
5345                            distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
5346                        }
5347                        GeneratedField::StateTableIds => {
5348                            if state_table_ids__.is_some() {
5349                                return Err(serde::de::Error::duplicate_field("stateTableIds"));
5350                            }
5351                            state_table_ids__ = 
5352                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5353                                    .into_iter().map(|x| x.0).collect())
5354                            ;
5355                        }
5356                        GeneratedField::UpstreamFragmentIds => {
5357                            if upstream_fragment_ids__.is_some() {
5358                                return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
5359                            }
5360                            upstream_fragment_ids__ = 
5361                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5362                                    .into_iter().map(|x| x.0).collect())
5363                            ;
5364                        }
5365                        GeneratedField::FragmentTypeMask => {
5366                            if fragment_type_mask__.is_some() {
5367                                return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
5368                            }
5369                            fragment_type_mask__ = 
5370                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5371                            ;
5372                        }
5373                        GeneratedField::Parallelism => {
5374                            if parallelism__.is_some() {
5375                                return Err(serde::de::Error::duplicate_field("parallelism"));
5376                            }
5377                            parallelism__ = 
5378                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5379                            ;
5380                        }
5381                        GeneratedField::VnodeCount => {
5382                            if vnode_count__.is_some() {
5383                                return Err(serde::de::Error::duplicate_field("vnodeCount"));
5384                            }
5385                            vnode_count__ = 
5386                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5387                            ;
5388                        }
5389                        GeneratedField::Node => {
5390                            if node__.is_some() {
5391                                return Err(serde::de::Error::duplicate_field("node"));
5392                            }
5393                            node__ = map_.next_value()?;
5394                        }
5395                    }
5396                }
5397                Ok(FragmentDistribution {
5398                    fragment_id: fragment_id__.unwrap_or_default(),
5399                    table_id: table_id__.unwrap_or_default(),
5400                    distribution_type: distribution_type__.unwrap_or_default(),
5401                    state_table_ids: state_table_ids__.unwrap_or_default(),
5402                    upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
5403                    fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
5404                    parallelism: parallelism__.unwrap_or_default(),
5405                    vnode_count: vnode_count__.unwrap_or_default(),
5406                    node: node__,
5407                })
5408            }
5409        }
5410        deserializer.deserialize_struct("meta.FragmentDistribution", FIELDS, GeneratedVisitor)
5411    }
5412}
5413impl serde::Serialize for FragmentIdToActorIdMap {
5414    #[allow(deprecated)]
5415    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5416    where
5417        S: serde::Serializer,
5418    {
5419        use serde::ser::SerializeStruct;
5420        let mut len = 0;
5421        if !self.map.is_empty() {
5422            len += 1;
5423        }
5424        let mut struct_ser = serializer.serialize_struct("meta.FragmentIdToActorIdMap", len)?;
5425        if !self.map.is_empty() {
5426            struct_ser.serialize_field("map", &self.map)?;
5427        }
5428        struct_ser.end()
5429    }
5430}
5431impl<'de> serde::Deserialize<'de> for FragmentIdToActorIdMap {
5432    #[allow(deprecated)]
5433    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5434    where
5435        D: serde::Deserializer<'de>,
5436    {
5437        const FIELDS: &[&str] = &[
5438            "map",
5439        ];
5440
5441        #[allow(clippy::enum_variant_names)]
5442        enum GeneratedField {
5443            Map,
5444        }
5445        impl<'de> serde::Deserialize<'de> for GeneratedField {
5446            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5447            where
5448                D: serde::Deserializer<'de>,
5449            {
5450                struct GeneratedVisitor;
5451
5452                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5453                    type Value = GeneratedField;
5454
5455                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5456                        write!(formatter, "expected one of: {:?}", &FIELDS)
5457                    }
5458
5459                    #[allow(unused_variables)]
5460                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5461                    where
5462                        E: serde::de::Error,
5463                    {
5464                        match value {
5465                            "map" => Ok(GeneratedField::Map),
5466                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5467                        }
5468                    }
5469                }
5470                deserializer.deserialize_identifier(GeneratedVisitor)
5471            }
5472        }
5473        struct GeneratedVisitor;
5474        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5475            type Value = FragmentIdToActorIdMap;
5476
5477            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5478                formatter.write_str("struct meta.FragmentIdToActorIdMap")
5479            }
5480
5481            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentIdToActorIdMap, V::Error>
5482                where
5483                    V: serde::de::MapAccess<'de>,
5484            {
5485                let mut map__ = None;
5486                while let Some(k) = map_.next_key()? {
5487                    match k {
5488                        GeneratedField::Map => {
5489                            if map__.is_some() {
5490                                return Err(serde::de::Error::duplicate_field("map"));
5491                            }
5492                            map__ = Some(
5493                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5494                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
5495                            );
5496                        }
5497                    }
5498                }
5499                Ok(FragmentIdToActorIdMap {
5500                    map: map__.unwrap_or_default(),
5501                })
5502            }
5503        }
5504        deserializer.deserialize_struct("meta.FragmentIdToActorIdMap", FIELDS, GeneratedVisitor)
5505    }
5506}
5507impl serde::Serialize for FragmentToRelationMap {
5508    #[allow(deprecated)]
5509    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5510    where
5511        S: serde::Serializer,
5512    {
5513        use serde::ser::SerializeStruct;
5514        let mut len = 0;
5515        if !self.fragment_to_relation_map.is_empty() {
5516            len += 1;
5517        }
5518        let mut struct_ser = serializer.serialize_struct("meta.FragmentToRelationMap", len)?;
5519        if !self.fragment_to_relation_map.is_empty() {
5520            struct_ser.serialize_field("fragmentToRelationMap", &self.fragment_to_relation_map)?;
5521        }
5522        struct_ser.end()
5523    }
5524}
5525impl<'de> serde::Deserialize<'de> for FragmentToRelationMap {
5526    #[allow(deprecated)]
5527    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5528    where
5529        D: serde::Deserializer<'de>,
5530    {
5531        const FIELDS: &[&str] = &[
5532            "fragment_to_relation_map",
5533            "fragmentToRelationMap",
5534        ];
5535
5536        #[allow(clippy::enum_variant_names)]
5537        enum GeneratedField {
5538            FragmentToRelationMap,
5539        }
5540        impl<'de> serde::Deserialize<'de> for GeneratedField {
5541            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5542            where
5543                D: serde::Deserializer<'de>,
5544            {
5545                struct GeneratedVisitor;
5546
5547                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5548                    type Value = GeneratedField;
5549
5550                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5551                        write!(formatter, "expected one of: {:?}", &FIELDS)
5552                    }
5553
5554                    #[allow(unused_variables)]
5555                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5556                    where
5557                        E: serde::de::Error,
5558                    {
5559                        match value {
5560                            "fragmentToRelationMap" | "fragment_to_relation_map" => Ok(GeneratedField::FragmentToRelationMap),
5561                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5562                        }
5563                    }
5564                }
5565                deserializer.deserialize_identifier(GeneratedVisitor)
5566            }
5567        }
5568        struct GeneratedVisitor;
5569        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5570            type Value = FragmentToRelationMap;
5571
5572            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5573                formatter.write_str("struct meta.FragmentToRelationMap")
5574            }
5575
5576            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentToRelationMap, V::Error>
5577                where
5578                    V: serde::de::MapAccess<'de>,
5579            {
5580                let mut fragment_to_relation_map__ = None;
5581                while let Some(k) = map_.next_key()? {
5582                    match k {
5583                        GeneratedField::FragmentToRelationMap => {
5584                            if fragment_to_relation_map__.is_some() {
5585                                return Err(serde::de::Error::duplicate_field("fragmentToRelationMap"));
5586                            }
5587                            fragment_to_relation_map__ = Some(
5588                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
5589                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
5590                            );
5591                        }
5592                    }
5593                }
5594                Ok(FragmentToRelationMap {
5595                    fragment_to_relation_map: fragment_to_relation_map__.unwrap_or_default(),
5596                })
5597            }
5598        }
5599        deserializer.deserialize_struct("meta.FragmentToRelationMap", FIELDS, GeneratedVisitor)
5600    }
5601}
5602impl serde::Serialize for FragmentWorkerSlotMapping {
5603    #[allow(deprecated)]
5604    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5605    where
5606        S: serde::Serializer,
5607    {
5608        use serde::ser::SerializeStruct;
5609        let mut len = 0;
5610        if self.fragment_id != 0 {
5611            len += 1;
5612        }
5613        if self.mapping.is_some() {
5614            len += 1;
5615        }
5616        let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMapping", len)?;
5617        if self.fragment_id != 0 {
5618            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
5619        }
5620        if let Some(v) = self.mapping.as_ref() {
5621            struct_ser.serialize_field("mapping", v)?;
5622        }
5623        struct_ser.end()
5624    }
5625}
5626impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMapping {
5627    #[allow(deprecated)]
5628    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5629    where
5630        D: serde::Deserializer<'de>,
5631    {
5632        const FIELDS: &[&str] = &[
5633            "fragment_id",
5634            "fragmentId",
5635            "mapping",
5636        ];
5637
5638        #[allow(clippy::enum_variant_names)]
5639        enum GeneratedField {
5640            FragmentId,
5641            Mapping,
5642        }
5643        impl<'de> serde::Deserialize<'de> for GeneratedField {
5644            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5645            where
5646                D: serde::Deserializer<'de>,
5647            {
5648                struct GeneratedVisitor;
5649
5650                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5651                    type Value = GeneratedField;
5652
5653                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5654                        write!(formatter, "expected one of: {:?}", &FIELDS)
5655                    }
5656
5657                    #[allow(unused_variables)]
5658                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5659                    where
5660                        E: serde::de::Error,
5661                    {
5662                        match value {
5663                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
5664                            "mapping" => Ok(GeneratedField::Mapping),
5665                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5666                        }
5667                    }
5668                }
5669                deserializer.deserialize_identifier(GeneratedVisitor)
5670            }
5671        }
5672        struct GeneratedVisitor;
5673        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5674            type Value = FragmentWorkerSlotMapping;
5675
5676            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5677                formatter.write_str("struct meta.FragmentWorkerSlotMapping")
5678            }
5679
5680            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMapping, V::Error>
5681                where
5682                    V: serde::de::MapAccess<'de>,
5683            {
5684                let mut fragment_id__ = None;
5685                let mut mapping__ = None;
5686                while let Some(k) = map_.next_key()? {
5687                    match k {
5688                        GeneratedField::FragmentId => {
5689                            if fragment_id__.is_some() {
5690                                return Err(serde::de::Error::duplicate_field("fragmentId"));
5691                            }
5692                            fragment_id__ = 
5693                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5694                            ;
5695                        }
5696                        GeneratedField::Mapping => {
5697                            if mapping__.is_some() {
5698                                return Err(serde::de::Error::duplicate_field("mapping"));
5699                            }
5700                            mapping__ = map_.next_value()?;
5701                        }
5702                    }
5703                }
5704                Ok(FragmentWorkerSlotMapping {
5705                    fragment_id: fragment_id__.unwrap_or_default(),
5706                    mapping: mapping__,
5707                })
5708            }
5709        }
5710        deserializer.deserialize_struct("meta.FragmentWorkerSlotMapping", FIELDS, GeneratedVisitor)
5711    }
5712}
5713impl serde::Serialize for FragmentWorkerSlotMappings {
5714    #[allow(deprecated)]
5715    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5716    where
5717        S: serde::Serializer,
5718    {
5719        use serde::ser::SerializeStruct;
5720        let mut len = 0;
5721        if !self.mappings.is_empty() {
5722            len += 1;
5723        }
5724        let mut struct_ser = serializer.serialize_struct("meta.FragmentWorkerSlotMappings", len)?;
5725        if !self.mappings.is_empty() {
5726            struct_ser.serialize_field("mappings", &self.mappings)?;
5727        }
5728        struct_ser.end()
5729    }
5730}
5731impl<'de> serde::Deserialize<'de> for FragmentWorkerSlotMappings {
5732    #[allow(deprecated)]
5733    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5734    where
5735        D: serde::Deserializer<'de>,
5736    {
5737        const FIELDS: &[&str] = &[
5738            "mappings",
5739        ];
5740
5741        #[allow(clippy::enum_variant_names)]
5742        enum GeneratedField {
5743            Mappings,
5744        }
5745        impl<'de> serde::Deserialize<'de> for GeneratedField {
5746            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5747            where
5748                D: serde::Deserializer<'de>,
5749            {
5750                struct GeneratedVisitor;
5751
5752                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5753                    type Value = GeneratedField;
5754
5755                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5756                        write!(formatter, "expected one of: {:?}", &FIELDS)
5757                    }
5758
5759                    #[allow(unused_variables)]
5760                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5761                    where
5762                        E: serde::de::Error,
5763                    {
5764                        match value {
5765                            "mappings" => Ok(GeneratedField::Mappings),
5766                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5767                        }
5768                    }
5769                }
5770                deserializer.deserialize_identifier(GeneratedVisitor)
5771            }
5772        }
5773        struct GeneratedVisitor;
5774        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5775            type Value = FragmentWorkerSlotMappings;
5776
5777            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5778                formatter.write_str("struct meta.FragmentWorkerSlotMappings")
5779            }
5780
5781            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FragmentWorkerSlotMappings, V::Error>
5782                where
5783                    V: serde::de::MapAccess<'de>,
5784            {
5785                let mut mappings__ = None;
5786                while let Some(k) = map_.next_key()? {
5787                    match k {
5788                        GeneratedField::Mappings => {
5789                            if mappings__.is_some() {
5790                                return Err(serde::de::Error::duplicate_field("mappings"));
5791                            }
5792                            mappings__ = Some(map_.next_value()?);
5793                        }
5794                    }
5795                }
5796                Ok(FragmentWorkerSlotMappings {
5797                    mappings: mappings__.unwrap_or_default(),
5798                })
5799            }
5800        }
5801        deserializer.deserialize_struct("meta.FragmentWorkerSlotMappings", FIELDS, GeneratedVisitor)
5802    }
5803}
5804impl serde::Serialize for GetClusterInfoRequest {
5805    #[allow(deprecated)]
5806    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5807    where
5808        S: serde::Serializer,
5809    {
5810        use serde::ser::SerializeStruct;
5811        let len = 0;
5812        let struct_ser = serializer.serialize_struct("meta.GetClusterInfoRequest", len)?;
5813        struct_ser.end()
5814    }
5815}
5816impl<'de> serde::Deserialize<'de> for GetClusterInfoRequest {
5817    #[allow(deprecated)]
5818    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5819    where
5820        D: serde::Deserializer<'de>,
5821    {
5822        const FIELDS: &[&str] = &[
5823        ];
5824
5825        #[allow(clippy::enum_variant_names)]
5826        enum GeneratedField {
5827        }
5828        impl<'de> serde::Deserialize<'de> for GeneratedField {
5829            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5830            where
5831                D: serde::Deserializer<'de>,
5832            {
5833                struct GeneratedVisitor;
5834
5835                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5836                    type Value = GeneratedField;
5837
5838                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5839                        write!(formatter, "expected one of: {:?}", &FIELDS)
5840                    }
5841
5842                    #[allow(unused_variables)]
5843                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5844                    where
5845                        E: serde::de::Error,
5846                    {
5847                            Err(serde::de::Error::unknown_field(value, FIELDS))
5848                    }
5849                }
5850                deserializer.deserialize_identifier(GeneratedVisitor)
5851            }
5852        }
5853        struct GeneratedVisitor;
5854        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5855            type Value = GetClusterInfoRequest;
5856
5857            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5858                formatter.write_str("struct meta.GetClusterInfoRequest")
5859            }
5860
5861            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoRequest, V::Error>
5862                where
5863                    V: serde::de::MapAccess<'de>,
5864            {
5865                while map_.next_key::<GeneratedField>()?.is_some() {
5866                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
5867                }
5868                Ok(GetClusterInfoRequest {
5869                })
5870            }
5871        }
5872        deserializer.deserialize_struct("meta.GetClusterInfoRequest", FIELDS, GeneratedVisitor)
5873    }
5874}
5875impl serde::Serialize for GetClusterInfoResponse {
5876    #[allow(deprecated)]
5877    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5878    where
5879        S: serde::Serializer,
5880    {
5881        use serde::ser::SerializeStruct;
5882        let mut len = 0;
5883        if !self.worker_nodes.is_empty() {
5884            len += 1;
5885        }
5886        if !self.table_fragments.is_empty() {
5887            len += 1;
5888        }
5889        if !self.actor_splits.is_empty() {
5890            len += 1;
5891        }
5892        if !self.source_infos.is_empty() {
5893            len += 1;
5894        }
5895        if self.revision != 0 {
5896            len += 1;
5897        }
5898        let mut struct_ser = serializer.serialize_struct("meta.GetClusterInfoResponse", len)?;
5899        if !self.worker_nodes.is_empty() {
5900            struct_ser.serialize_field("workerNodes", &self.worker_nodes)?;
5901        }
5902        if !self.table_fragments.is_empty() {
5903            struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
5904        }
5905        if !self.actor_splits.is_empty() {
5906            struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
5907        }
5908        if !self.source_infos.is_empty() {
5909            struct_ser.serialize_field("sourceInfos", &self.source_infos)?;
5910        }
5911        if self.revision != 0 {
5912            #[allow(clippy::needless_borrow)]
5913            #[allow(clippy::needless_borrows_for_generic_args)]
5914            struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
5915        }
5916        struct_ser.end()
5917    }
5918}
5919impl<'de> serde::Deserialize<'de> for GetClusterInfoResponse {
5920    #[allow(deprecated)]
5921    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5922    where
5923        D: serde::Deserializer<'de>,
5924    {
5925        const FIELDS: &[&str] = &[
5926            "worker_nodes",
5927            "workerNodes",
5928            "table_fragments",
5929            "tableFragments",
5930            "actor_splits",
5931            "actorSplits",
5932            "source_infos",
5933            "sourceInfos",
5934            "revision",
5935        ];
5936
5937        #[allow(clippy::enum_variant_names)]
5938        enum GeneratedField {
5939            WorkerNodes,
5940            TableFragments,
5941            ActorSplits,
5942            SourceInfos,
5943            Revision,
5944        }
5945        impl<'de> serde::Deserialize<'de> for GeneratedField {
5946            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5947            where
5948                D: serde::Deserializer<'de>,
5949            {
5950                struct GeneratedVisitor;
5951
5952                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5953                    type Value = GeneratedField;
5954
5955                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5956                        write!(formatter, "expected one of: {:?}", &FIELDS)
5957                    }
5958
5959                    #[allow(unused_variables)]
5960                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5961                    where
5962                        E: serde::de::Error,
5963                    {
5964                        match value {
5965                            "workerNodes" | "worker_nodes" => Ok(GeneratedField::WorkerNodes),
5966                            "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
5967                            "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
5968                            "sourceInfos" | "source_infos" => Ok(GeneratedField::SourceInfos),
5969                            "revision" => Ok(GeneratedField::Revision),
5970                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5971                        }
5972                    }
5973                }
5974                deserializer.deserialize_identifier(GeneratedVisitor)
5975            }
5976        }
5977        struct GeneratedVisitor;
5978        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5979            type Value = GetClusterInfoResponse;
5980
5981            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5982                formatter.write_str("struct meta.GetClusterInfoResponse")
5983            }
5984
5985            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterInfoResponse, V::Error>
5986                where
5987                    V: serde::de::MapAccess<'de>,
5988            {
5989                let mut worker_nodes__ = None;
5990                let mut table_fragments__ = None;
5991                let mut actor_splits__ = None;
5992                let mut source_infos__ = None;
5993                let mut revision__ = None;
5994                while let Some(k) = map_.next_key()? {
5995                    match k {
5996                        GeneratedField::WorkerNodes => {
5997                            if worker_nodes__.is_some() {
5998                                return Err(serde::de::Error::duplicate_field("workerNodes"));
5999                            }
6000                            worker_nodes__ = Some(map_.next_value()?);
6001                        }
6002                        GeneratedField::TableFragments => {
6003                            if table_fragments__.is_some() {
6004                                return Err(serde::de::Error::duplicate_field("tableFragments"));
6005                            }
6006                            table_fragments__ = Some(map_.next_value()?);
6007                        }
6008                        GeneratedField::ActorSplits => {
6009                            if actor_splits__.is_some() {
6010                                return Err(serde::de::Error::duplicate_field("actorSplits"));
6011                            }
6012                            actor_splits__ = Some(
6013                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6014                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
6015                            );
6016                        }
6017                        GeneratedField::SourceInfos => {
6018                            if source_infos__.is_some() {
6019                                return Err(serde::de::Error::duplicate_field("sourceInfos"));
6020                            }
6021                            source_infos__ = Some(
6022                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
6023                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
6024                            );
6025                        }
6026                        GeneratedField::Revision => {
6027                            if revision__.is_some() {
6028                                return Err(serde::de::Error::duplicate_field("revision"));
6029                            }
6030                            revision__ = 
6031                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6032                            ;
6033                        }
6034                    }
6035                }
6036                Ok(GetClusterInfoResponse {
6037                    worker_nodes: worker_nodes__.unwrap_or_default(),
6038                    table_fragments: table_fragments__.unwrap_or_default(),
6039                    actor_splits: actor_splits__.unwrap_or_default(),
6040                    source_infos: source_infos__.unwrap_or_default(),
6041                    revision: revision__.unwrap_or_default(),
6042                })
6043            }
6044        }
6045        deserializer.deserialize_struct("meta.GetClusterInfoResponse", FIELDS, GeneratedVisitor)
6046    }
6047}
6048impl serde::Serialize for GetClusterLimitsRequest {
6049    #[allow(deprecated)]
6050    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6051    where
6052        S: serde::Serializer,
6053    {
6054        use serde::ser::SerializeStruct;
6055        let len = 0;
6056        let struct_ser = serializer.serialize_struct("meta.GetClusterLimitsRequest", len)?;
6057        struct_ser.end()
6058    }
6059}
6060impl<'de> serde::Deserialize<'de> for GetClusterLimitsRequest {
6061    #[allow(deprecated)]
6062    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6063    where
6064        D: serde::Deserializer<'de>,
6065    {
6066        const FIELDS: &[&str] = &[
6067        ];
6068
6069        #[allow(clippy::enum_variant_names)]
6070        enum GeneratedField {
6071        }
6072        impl<'de> serde::Deserialize<'de> for GeneratedField {
6073            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6074            where
6075                D: serde::Deserializer<'de>,
6076            {
6077                struct GeneratedVisitor;
6078
6079                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6080                    type Value = GeneratedField;
6081
6082                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6083                        write!(formatter, "expected one of: {:?}", &FIELDS)
6084                    }
6085
6086                    #[allow(unused_variables)]
6087                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6088                    where
6089                        E: serde::de::Error,
6090                    {
6091                            Err(serde::de::Error::unknown_field(value, FIELDS))
6092                    }
6093                }
6094                deserializer.deserialize_identifier(GeneratedVisitor)
6095            }
6096        }
6097        struct GeneratedVisitor;
6098        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6099            type Value = GetClusterLimitsRequest;
6100
6101            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6102                formatter.write_str("struct meta.GetClusterLimitsRequest")
6103            }
6104
6105            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsRequest, V::Error>
6106                where
6107                    V: serde::de::MapAccess<'de>,
6108            {
6109                while map_.next_key::<GeneratedField>()?.is_some() {
6110                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6111                }
6112                Ok(GetClusterLimitsRequest {
6113                })
6114            }
6115        }
6116        deserializer.deserialize_struct("meta.GetClusterLimitsRequest", FIELDS, GeneratedVisitor)
6117    }
6118}
6119impl serde::Serialize for GetClusterLimitsResponse {
6120    #[allow(deprecated)]
6121    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6122    where
6123        S: serde::Serializer,
6124    {
6125        use serde::ser::SerializeStruct;
6126        let mut len = 0;
6127        if !self.active_limits.is_empty() {
6128            len += 1;
6129        }
6130        let mut struct_ser = serializer.serialize_struct("meta.GetClusterLimitsResponse", len)?;
6131        if !self.active_limits.is_empty() {
6132            struct_ser.serialize_field("activeLimits", &self.active_limits)?;
6133        }
6134        struct_ser.end()
6135    }
6136}
6137impl<'de> serde::Deserialize<'de> for GetClusterLimitsResponse {
6138    #[allow(deprecated)]
6139    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6140    where
6141        D: serde::Deserializer<'de>,
6142    {
6143        const FIELDS: &[&str] = &[
6144            "active_limits",
6145            "activeLimits",
6146        ];
6147
6148        #[allow(clippy::enum_variant_names)]
6149        enum GeneratedField {
6150            ActiveLimits,
6151        }
6152        impl<'de> serde::Deserialize<'de> for GeneratedField {
6153            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6154            where
6155                D: serde::Deserializer<'de>,
6156            {
6157                struct GeneratedVisitor;
6158
6159                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6160                    type Value = GeneratedField;
6161
6162                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6163                        write!(formatter, "expected one of: {:?}", &FIELDS)
6164                    }
6165
6166                    #[allow(unused_variables)]
6167                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6168                    where
6169                        E: serde::de::Error,
6170                    {
6171                        match value {
6172                            "activeLimits" | "active_limits" => Ok(GeneratedField::ActiveLimits),
6173                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6174                        }
6175                    }
6176                }
6177                deserializer.deserialize_identifier(GeneratedVisitor)
6178            }
6179        }
6180        struct GeneratedVisitor;
6181        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6182            type Value = GetClusterLimitsResponse;
6183
6184            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6185                formatter.write_str("struct meta.GetClusterLimitsResponse")
6186            }
6187
6188            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterLimitsResponse, V::Error>
6189                where
6190                    V: serde::de::MapAccess<'de>,
6191            {
6192                let mut active_limits__ = None;
6193                while let Some(k) = map_.next_key()? {
6194                    match k {
6195                        GeneratedField::ActiveLimits => {
6196                            if active_limits__.is_some() {
6197                                return Err(serde::de::Error::duplicate_field("activeLimits"));
6198                            }
6199                            active_limits__ = Some(map_.next_value()?);
6200                        }
6201                    }
6202                }
6203                Ok(GetClusterLimitsResponse {
6204                    active_limits: active_limits__.unwrap_or_default(),
6205                })
6206            }
6207        }
6208        deserializer.deserialize_struct("meta.GetClusterLimitsResponse", FIELDS, GeneratedVisitor)
6209    }
6210}
6211impl serde::Serialize for GetClusterRecoveryStatusRequest {
6212    #[allow(deprecated)]
6213    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6214    where
6215        S: serde::Serializer,
6216    {
6217        use serde::ser::SerializeStruct;
6218        let len = 0;
6219        let struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusRequest", len)?;
6220        struct_ser.end()
6221    }
6222}
6223impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusRequest {
6224    #[allow(deprecated)]
6225    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6226    where
6227        D: serde::Deserializer<'de>,
6228    {
6229        const FIELDS: &[&str] = &[
6230        ];
6231
6232        #[allow(clippy::enum_variant_names)]
6233        enum GeneratedField {
6234        }
6235        impl<'de> serde::Deserialize<'de> for GeneratedField {
6236            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6237            where
6238                D: serde::Deserializer<'de>,
6239            {
6240                struct GeneratedVisitor;
6241
6242                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6243                    type Value = GeneratedField;
6244
6245                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6246                        write!(formatter, "expected one of: {:?}", &FIELDS)
6247                    }
6248
6249                    #[allow(unused_variables)]
6250                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6251                    where
6252                        E: serde::de::Error,
6253                    {
6254                            Err(serde::de::Error::unknown_field(value, FIELDS))
6255                    }
6256                }
6257                deserializer.deserialize_identifier(GeneratedVisitor)
6258            }
6259        }
6260        struct GeneratedVisitor;
6261        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6262            type Value = GetClusterRecoveryStatusRequest;
6263
6264            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6265                formatter.write_str("struct meta.GetClusterRecoveryStatusRequest")
6266            }
6267
6268            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusRequest, V::Error>
6269                where
6270                    V: serde::de::MapAccess<'de>,
6271            {
6272                while map_.next_key::<GeneratedField>()?.is_some() {
6273                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6274                }
6275                Ok(GetClusterRecoveryStatusRequest {
6276                })
6277            }
6278        }
6279        deserializer.deserialize_struct("meta.GetClusterRecoveryStatusRequest", FIELDS, GeneratedVisitor)
6280    }
6281}
6282impl serde::Serialize for GetClusterRecoveryStatusResponse {
6283    #[allow(deprecated)]
6284    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6285    where
6286        S: serde::Serializer,
6287    {
6288        use serde::ser::SerializeStruct;
6289        let mut len = 0;
6290        if self.status != 0 {
6291            len += 1;
6292        }
6293        let mut struct_ser = serializer.serialize_struct("meta.GetClusterRecoveryStatusResponse", len)?;
6294        if self.status != 0 {
6295            let v = RecoveryStatus::try_from(self.status)
6296                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.status)))?;
6297            struct_ser.serialize_field("status", &v)?;
6298        }
6299        struct_ser.end()
6300    }
6301}
6302impl<'de> serde::Deserialize<'de> for GetClusterRecoveryStatusResponse {
6303    #[allow(deprecated)]
6304    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6305    where
6306        D: serde::Deserializer<'de>,
6307    {
6308        const FIELDS: &[&str] = &[
6309            "status",
6310        ];
6311
6312        #[allow(clippy::enum_variant_names)]
6313        enum GeneratedField {
6314            Status,
6315        }
6316        impl<'de> serde::Deserialize<'de> for GeneratedField {
6317            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6318            where
6319                D: serde::Deserializer<'de>,
6320            {
6321                struct GeneratedVisitor;
6322
6323                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6324                    type Value = GeneratedField;
6325
6326                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6327                        write!(formatter, "expected one of: {:?}", &FIELDS)
6328                    }
6329
6330                    #[allow(unused_variables)]
6331                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6332                    where
6333                        E: serde::de::Error,
6334                    {
6335                        match value {
6336                            "status" => Ok(GeneratedField::Status),
6337                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6338                        }
6339                    }
6340                }
6341                deserializer.deserialize_identifier(GeneratedVisitor)
6342            }
6343        }
6344        struct GeneratedVisitor;
6345        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6346            type Value = GetClusterRecoveryStatusResponse;
6347
6348            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6349                formatter.write_str("struct meta.GetClusterRecoveryStatusResponse")
6350            }
6351
6352            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetClusterRecoveryStatusResponse, V::Error>
6353                where
6354                    V: serde::de::MapAccess<'de>,
6355            {
6356                let mut status__ = None;
6357                while let Some(k) = map_.next_key()? {
6358                    match k {
6359                        GeneratedField::Status => {
6360                            if status__.is_some() {
6361                                return Err(serde::de::Error::duplicate_field("status"));
6362                            }
6363                            status__ = Some(map_.next_value::<RecoveryStatus>()? as i32);
6364                        }
6365                    }
6366                }
6367                Ok(GetClusterRecoveryStatusResponse {
6368                    status: status__.unwrap_or_default(),
6369                })
6370            }
6371        }
6372        deserializer.deserialize_struct("meta.GetClusterRecoveryStatusResponse", FIELDS, GeneratedVisitor)
6373    }
6374}
6375impl serde::Serialize for GetFragmentByIdRequest {
6376    #[allow(deprecated)]
6377    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6378    where
6379        S: serde::Serializer,
6380    {
6381        use serde::ser::SerializeStruct;
6382        let mut len = 0;
6383        if self.fragment_id != 0 {
6384            len += 1;
6385        }
6386        let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdRequest", len)?;
6387        if self.fragment_id != 0 {
6388            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
6389        }
6390        struct_ser.end()
6391    }
6392}
6393impl<'de> serde::Deserialize<'de> for GetFragmentByIdRequest {
6394    #[allow(deprecated)]
6395    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6396    where
6397        D: serde::Deserializer<'de>,
6398    {
6399        const FIELDS: &[&str] = &[
6400            "fragment_id",
6401            "fragmentId",
6402        ];
6403
6404        #[allow(clippy::enum_variant_names)]
6405        enum GeneratedField {
6406            FragmentId,
6407        }
6408        impl<'de> serde::Deserialize<'de> for GeneratedField {
6409            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6410            where
6411                D: serde::Deserializer<'de>,
6412            {
6413                struct GeneratedVisitor;
6414
6415                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6416                    type Value = GeneratedField;
6417
6418                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6419                        write!(formatter, "expected one of: {:?}", &FIELDS)
6420                    }
6421
6422                    #[allow(unused_variables)]
6423                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6424                    where
6425                        E: serde::de::Error,
6426                    {
6427                        match value {
6428                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
6429                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6430                        }
6431                    }
6432                }
6433                deserializer.deserialize_identifier(GeneratedVisitor)
6434            }
6435        }
6436        struct GeneratedVisitor;
6437        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6438            type Value = GetFragmentByIdRequest;
6439
6440            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6441                formatter.write_str("struct meta.GetFragmentByIdRequest")
6442            }
6443
6444            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdRequest, V::Error>
6445                where
6446                    V: serde::de::MapAccess<'de>,
6447            {
6448                let mut fragment_id__ = None;
6449                while let Some(k) = map_.next_key()? {
6450                    match k {
6451                        GeneratedField::FragmentId => {
6452                            if fragment_id__.is_some() {
6453                                return Err(serde::de::Error::duplicate_field("fragmentId"));
6454                            }
6455                            fragment_id__ = 
6456                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6457                            ;
6458                        }
6459                    }
6460                }
6461                Ok(GetFragmentByIdRequest {
6462                    fragment_id: fragment_id__.unwrap_or_default(),
6463                })
6464            }
6465        }
6466        deserializer.deserialize_struct("meta.GetFragmentByIdRequest", FIELDS, GeneratedVisitor)
6467    }
6468}
6469impl serde::Serialize for GetFragmentByIdResponse {
6470    #[allow(deprecated)]
6471    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6472    where
6473        S: serde::Serializer,
6474    {
6475        use serde::ser::SerializeStruct;
6476        let mut len = 0;
6477        if self.distribution.is_some() {
6478            len += 1;
6479        }
6480        let mut struct_ser = serializer.serialize_struct("meta.GetFragmentByIdResponse", len)?;
6481        if let Some(v) = self.distribution.as_ref() {
6482            struct_ser.serialize_field("distribution", v)?;
6483        }
6484        struct_ser.end()
6485    }
6486}
6487impl<'de> serde::Deserialize<'de> for GetFragmentByIdResponse {
6488    #[allow(deprecated)]
6489    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6490    where
6491        D: serde::Deserializer<'de>,
6492    {
6493        const FIELDS: &[&str] = &[
6494            "distribution",
6495        ];
6496
6497        #[allow(clippy::enum_variant_names)]
6498        enum GeneratedField {
6499            Distribution,
6500        }
6501        impl<'de> serde::Deserialize<'de> for GeneratedField {
6502            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6503            where
6504                D: serde::Deserializer<'de>,
6505            {
6506                struct GeneratedVisitor;
6507
6508                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6509                    type Value = GeneratedField;
6510
6511                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6512                        write!(formatter, "expected one of: {:?}", &FIELDS)
6513                    }
6514
6515                    #[allow(unused_variables)]
6516                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6517                    where
6518                        E: serde::de::Error,
6519                    {
6520                        match value {
6521                            "distribution" => Ok(GeneratedField::Distribution),
6522                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6523                        }
6524                    }
6525                }
6526                deserializer.deserialize_identifier(GeneratedVisitor)
6527            }
6528        }
6529        struct GeneratedVisitor;
6530        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6531            type Value = GetFragmentByIdResponse;
6532
6533            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6534                formatter.write_str("struct meta.GetFragmentByIdResponse")
6535            }
6536
6537            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetFragmentByIdResponse, V::Error>
6538                where
6539                    V: serde::de::MapAccess<'de>,
6540            {
6541                let mut distribution__ = None;
6542                while let Some(k) = map_.next_key()? {
6543                    match k {
6544                        GeneratedField::Distribution => {
6545                            if distribution__.is_some() {
6546                                return Err(serde::de::Error::duplicate_field("distribution"));
6547                            }
6548                            distribution__ = map_.next_value()?;
6549                        }
6550                    }
6551                }
6552                Ok(GetFragmentByIdResponse {
6553                    distribution: distribution__,
6554                })
6555            }
6556        }
6557        deserializer.deserialize_struct("meta.GetFragmentByIdResponse", FIELDS, GeneratedVisitor)
6558    }
6559}
6560impl serde::Serialize for GetMetaStoreInfoRequest {
6561    #[allow(deprecated)]
6562    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6563    where
6564        S: serde::Serializer,
6565    {
6566        use serde::ser::SerializeStruct;
6567        let len = 0;
6568        let struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoRequest", len)?;
6569        struct_ser.end()
6570    }
6571}
6572impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoRequest {
6573    #[allow(deprecated)]
6574    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6575    where
6576        D: serde::Deserializer<'de>,
6577    {
6578        const FIELDS: &[&str] = &[
6579        ];
6580
6581        #[allow(clippy::enum_variant_names)]
6582        enum GeneratedField {
6583        }
6584        impl<'de> serde::Deserialize<'de> for GeneratedField {
6585            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6586            where
6587                D: serde::Deserializer<'de>,
6588            {
6589                struct GeneratedVisitor;
6590
6591                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6592                    type Value = GeneratedField;
6593
6594                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6595                        write!(formatter, "expected one of: {:?}", &FIELDS)
6596                    }
6597
6598                    #[allow(unused_variables)]
6599                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6600                    where
6601                        E: serde::de::Error,
6602                    {
6603                            Err(serde::de::Error::unknown_field(value, FIELDS))
6604                    }
6605                }
6606                deserializer.deserialize_identifier(GeneratedVisitor)
6607            }
6608        }
6609        struct GeneratedVisitor;
6610        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6611            type Value = GetMetaStoreInfoRequest;
6612
6613            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6614                formatter.write_str("struct meta.GetMetaStoreInfoRequest")
6615            }
6616
6617            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoRequest, V::Error>
6618                where
6619                    V: serde::de::MapAccess<'de>,
6620            {
6621                while map_.next_key::<GeneratedField>()?.is_some() {
6622                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6623                }
6624                Ok(GetMetaStoreInfoRequest {
6625                })
6626            }
6627        }
6628        deserializer.deserialize_struct("meta.GetMetaStoreInfoRequest", FIELDS, GeneratedVisitor)
6629    }
6630}
6631impl serde::Serialize for GetMetaStoreInfoResponse {
6632    #[allow(deprecated)]
6633    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6634    where
6635        S: serde::Serializer,
6636    {
6637        use serde::ser::SerializeStruct;
6638        let mut len = 0;
6639        if !self.meta_store_endpoint.is_empty() {
6640            len += 1;
6641        }
6642        let mut struct_ser = serializer.serialize_struct("meta.GetMetaStoreInfoResponse", len)?;
6643        if !self.meta_store_endpoint.is_empty() {
6644            struct_ser.serialize_field("metaStoreEndpoint", &self.meta_store_endpoint)?;
6645        }
6646        struct_ser.end()
6647    }
6648}
6649impl<'de> serde::Deserialize<'de> for GetMetaStoreInfoResponse {
6650    #[allow(deprecated)]
6651    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6652    where
6653        D: serde::Deserializer<'de>,
6654    {
6655        const FIELDS: &[&str] = &[
6656            "meta_store_endpoint",
6657            "metaStoreEndpoint",
6658        ];
6659
6660        #[allow(clippy::enum_variant_names)]
6661        enum GeneratedField {
6662            MetaStoreEndpoint,
6663        }
6664        impl<'de> serde::Deserialize<'de> for GeneratedField {
6665            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6666            where
6667                D: serde::Deserializer<'de>,
6668            {
6669                struct GeneratedVisitor;
6670
6671                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6672                    type Value = GeneratedField;
6673
6674                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6675                        write!(formatter, "expected one of: {:?}", &FIELDS)
6676                    }
6677
6678                    #[allow(unused_variables)]
6679                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6680                    where
6681                        E: serde::de::Error,
6682                    {
6683                        match value {
6684                            "metaStoreEndpoint" | "meta_store_endpoint" => Ok(GeneratedField::MetaStoreEndpoint),
6685                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6686                        }
6687                    }
6688                }
6689                deserializer.deserialize_identifier(GeneratedVisitor)
6690            }
6691        }
6692        struct GeneratedVisitor;
6693        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6694            type Value = GetMetaStoreInfoResponse;
6695
6696            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6697                formatter.write_str("struct meta.GetMetaStoreInfoResponse")
6698            }
6699
6700            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetMetaStoreInfoResponse, V::Error>
6701                where
6702                    V: serde::de::MapAccess<'de>,
6703            {
6704                let mut meta_store_endpoint__ = None;
6705                while let Some(k) = map_.next_key()? {
6706                    match k {
6707                        GeneratedField::MetaStoreEndpoint => {
6708                            if meta_store_endpoint__.is_some() {
6709                                return Err(serde::de::Error::duplicate_field("metaStoreEndpoint"));
6710                            }
6711                            meta_store_endpoint__ = Some(map_.next_value()?);
6712                        }
6713                    }
6714                }
6715                Ok(GetMetaStoreInfoResponse {
6716                    meta_store_endpoint: meta_store_endpoint__.unwrap_or_default(),
6717                })
6718            }
6719        }
6720        deserializer.deserialize_struct("meta.GetMetaStoreInfoResponse", FIELDS, GeneratedVisitor)
6721    }
6722}
6723impl serde::Serialize for GetServerlessStreamingJobsStatusRequest {
6724    #[allow(deprecated)]
6725    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6726    where
6727        S: serde::Serializer,
6728    {
6729        use serde::ser::SerializeStruct;
6730        let len = 0;
6731        let struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusRequest", len)?;
6732        struct_ser.end()
6733    }
6734}
6735impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusRequest {
6736    #[allow(deprecated)]
6737    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6738    where
6739        D: serde::Deserializer<'de>,
6740    {
6741        const FIELDS: &[&str] = &[
6742        ];
6743
6744        #[allow(clippy::enum_variant_names)]
6745        enum GeneratedField {
6746        }
6747        impl<'de> serde::Deserialize<'de> for GeneratedField {
6748            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6749            where
6750                D: serde::Deserializer<'de>,
6751            {
6752                struct GeneratedVisitor;
6753
6754                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6755                    type Value = GeneratedField;
6756
6757                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6758                        write!(formatter, "expected one of: {:?}", &FIELDS)
6759                    }
6760
6761                    #[allow(unused_variables)]
6762                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6763                    where
6764                        E: serde::de::Error,
6765                    {
6766                            Err(serde::de::Error::unknown_field(value, FIELDS))
6767                    }
6768                }
6769                deserializer.deserialize_identifier(GeneratedVisitor)
6770            }
6771        }
6772        struct GeneratedVisitor;
6773        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6774            type Value = GetServerlessStreamingJobsStatusRequest;
6775
6776            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6777                formatter.write_str("struct meta.GetServerlessStreamingJobsStatusRequest")
6778            }
6779
6780            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusRequest, V::Error>
6781                where
6782                    V: serde::de::MapAccess<'de>,
6783            {
6784                while map_.next_key::<GeneratedField>()?.is_some() {
6785                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6786                }
6787                Ok(GetServerlessStreamingJobsStatusRequest {
6788                })
6789            }
6790        }
6791        deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusRequest", FIELDS, GeneratedVisitor)
6792    }
6793}
6794impl serde::Serialize for GetServerlessStreamingJobsStatusResponse {
6795    #[allow(deprecated)]
6796    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6797    where
6798        S: serde::Serializer,
6799    {
6800        use serde::ser::SerializeStruct;
6801        let mut len = 0;
6802        if !self.streaming_job_statuses.is_empty() {
6803            len += 1;
6804        }
6805        let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse", len)?;
6806        if !self.streaming_job_statuses.is_empty() {
6807            struct_ser.serialize_field("streamingJobStatuses", &self.streaming_job_statuses)?;
6808        }
6809        struct_ser.end()
6810    }
6811}
6812impl<'de> serde::Deserialize<'de> for GetServerlessStreamingJobsStatusResponse {
6813    #[allow(deprecated)]
6814    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6815    where
6816        D: serde::Deserializer<'de>,
6817    {
6818        const FIELDS: &[&str] = &[
6819            "streaming_job_statuses",
6820            "streamingJobStatuses",
6821        ];
6822
6823        #[allow(clippy::enum_variant_names)]
6824        enum GeneratedField {
6825            StreamingJobStatuses,
6826        }
6827        impl<'de> serde::Deserialize<'de> for GeneratedField {
6828            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6829            where
6830                D: serde::Deserializer<'de>,
6831            {
6832                struct GeneratedVisitor;
6833
6834                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6835                    type Value = GeneratedField;
6836
6837                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6838                        write!(formatter, "expected one of: {:?}", &FIELDS)
6839                    }
6840
6841                    #[allow(unused_variables)]
6842                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6843                    where
6844                        E: serde::de::Error,
6845                    {
6846                        match value {
6847                            "streamingJobStatuses" | "streaming_job_statuses" => Ok(GeneratedField::StreamingJobStatuses),
6848                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6849                        }
6850                    }
6851                }
6852                deserializer.deserialize_identifier(GeneratedVisitor)
6853            }
6854        }
6855        struct GeneratedVisitor;
6856        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6857            type Value = GetServerlessStreamingJobsStatusResponse;
6858
6859            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6860                formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse")
6861            }
6862
6863            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServerlessStreamingJobsStatusResponse, V::Error>
6864                where
6865                    V: serde::de::MapAccess<'de>,
6866            {
6867                let mut streaming_job_statuses__ = None;
6868                while let Some(k) = map_.next_key()? {
6869                    match k {
6870                        GeneratedField::StreamingJobStatuses => {
6871                            if streaming_job_statuses__.is_some() {
6872                                return Err(serde::de::Error::duplicate_field("streamingJobStatuses"));
6873                            }
6874                            streaming_job_statuses__ = Some(map_.next_value()?);
6875                        }
6876                    }
6877                }
6878                Ok(GetServerlessStreamingJobsStatusResponse {
6879                    streaming_job_statuses: streaming_job_statuses__.unwrap_or_default(),
6880                })
6881            }
6882        }
6883        deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse", FIELDS, GeneratedVisitor)
6884    }
6885}
6886impl serde::Serialize for get_serverless_streaming_jobs_status_response::Status {
6887    #[allow(deprecated)]
6888    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6889    where
6890        S: serde::Serializer,
6891    {
6892        use serde::ser::SerializeStruct;
6893        let mut len = 0;
6894        if self.table_id != 0 {
6895            len += 1;
6896        }
6897        if !self.node_label.is_empty() {
6898            len += 1;
6899        }
6900        if self.backfill_done {
6901            len += 1;
6902        }
6903        let mut struct_ser = serializer.serialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", len)?;
6904        if self.table_id != 0 {
6905            struct_ser.serialize_field("tableId", &self.table_id)?;
6906        }
6907        if !self.node_label.is_empty() {
6908            struct_ser.serialize_field("nodeLabel", &self.node_label)?;
6909        }
6910        if self.backfill_done {
6911            struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
6912        }
6913        struct_ser.end()
6914    }
6915}
6916impl<'de> serde::Deserialize<'de> for get_serverless_streaming_jobs_status_response::Status {
6917    #[allow(deprecated)]
6918    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6919    where
6920        D: serde::Deserializer<'de>,
6921    {
6922        const FIELDS: &[&str] = &[
6923            "table_id",
6924            "tableId",
6925            "node_label",
6926            "nodeLabel",
6927            "backfill_done",
6928            "backfillDone",
6929        ];
6930
6931        #[allow(clippy::enum_variant_names)]
6932        enum GeneratedField {
6933            TableId,
6934            NodeLabel,
6935            BackfillDone,
6936        }
6937        impl<'de> serde::Deserialize<'de> for GeneratedField {
6938            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6939            where
6940                D: serde::Deserializer<'de>,
6941            {
6942                struct GeneratedVisitor;
6943
6944                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6945                    type Value = GeneratedField;
6946
6947                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6948                        write!(formatter, "expected one of: {:?}", &FIELDS)
6949                    }
6950
6951                    #[allow(unused_variables)]
6952                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6953                    where
6954                        E: serde::de::Error,
6955                    {
6956                        match value {
6957                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
6958                            "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
6959                            "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
6960                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6961                        }
6962                    }
6963                }
6964                deserializer.deserialize_identifier(GeneratedVisitor)
6965            }
6966        }
6967        struct GeneratedVisitor;
6968        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6969            type Value = get_serverless_streaming_jobs_status_response::Status;
6970
6971            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6972                formatter.write_str("struct meta.GetServerlessStreamingJobsStatusResponse.Status")
6973            }
6974
6975            fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_serverless_streaming_jobs_status_response::Status, V::Error>
6976                where
6977                    V: serde::de::MapAccess<'de>,
6978            {
6979                let mut table_id__ = None;
6980                let mut node_label__ = None;
6981                let mut backfill_done__ = None;
6982                while let Some(k) = map_.next_key()? {
6983                    match k {
6984                        GeneratedField::TableId => {
6985                            if table_id__.is_some() {
6986                                return Err(serde::de::Error::duplicate_field("tableId"));
6987                            }
6988                            table_id__ = 
6989                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6990                            ;
6991                        }
6992                        GeneratedField::NodeLabel => {
6993                            if node_label__.is_some() {
6994                                return Err(serde::de::Error::duplicate_field("nodeLabel"));
6995                            }
6996                            node_label__ = Some(map_.next_value()?);
6997                        }
6998                        GeneratedField::BackfillDone => {
6999                            if backfill_done__.is_some() {
7000                                return Err(serde::de::Error::duplicate_field("backfillDone"));
7001                            }
7002                            backfill_done__ = Some(map_.next_value()?);
7003                        }
7004                    }
7005                }
7006                Ok(get_serverless_streaming_jobs_status_response::Status {
7007                    table_id: table_id__.unwrap_or_default(),
7008                    node_label: node_label__.unwrap_or_default(),
7009                    backfill_done: backfill_done__.unwrap_or_default(),
7010                })
7011            }
7012        }
7013        deserializer.deserialize_struct("meta.GetServerlessStreamingJobsStatusResponse.Status", FIELDS, GeneratedVisitor)
7014    }
7015}
7016impl serde::Serialize for GetServingVnodeMappingsRequest {
7017    #[allow(deprecated)]
7018    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7019    where
7020        S: serde::Serializer,
7021    {
7022        use serde::ser::SerializeStruct;
7023        let len = 0;
7024        let struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsRequest", len)?;
7025        struct_ser.end()
7026    }
7027}
7028impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsRequest {
7029    #[allow(deprecated)]
7030    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7031    where
7032        D: serde::Deserializer<'de>,
7033    {
7034        const FIELDS: &[&str] = &[
7035        ];
7036
7037        #[allow(clippy::enum_variant_names)]
7038        enum GeneratedField {
7039        }
7040        impl<'de> serde::Deserialize<'de> for GeneratedField {
7041            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7042            where
7043                D: serde::Deserializer<'de>,
7044            {
7045                struct GeneratedVisitor;
7046
7047                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7048                    type Value = GeneratedField;
7049
7050                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7051                        write!(formatter, "expected one of: {:?}", &FIELDS)
7052                    }
7053
7054                    #[allow(unused_variables)]
7055                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7056                    where
7057                        E: serde::de::Error,
7058                    {
7059                            Err(serde::de::Error::unknown_field(value, FIELDS))
7060                    }
7061                }
7062                deserializer.deserialize_identifier(GeneratedVisitor)
7063            }
7064        }
7065        struct GeneratedVisitor;
7066        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7067            type Value = GetServingVnodeMappingsRequest;
7068
7069            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7070                formatter.write_str("struct meta.GetServingVnodeMappingsRequest")
7071            }
7072
7073            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsRequest, V::Error>
7074                where
7075                    V: serde::de::MapAccess<'de>,
7076            {
7077                while map_.next_key::<GeneratedField>()?.is_some() {
7078                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7079                }
7080                Ok(GetServingVnodeMappingsRequest {
7081                })
7082            }
7083        }
7084        deserializer.deserialize_struct("meta.GetServingVnodeMappingsRequest", FIELDS, GeneratedVisitor)
7085    }
7086}
7087impl serde::Serialize for GetServingVnodeMappingsResponse {
7088    #[allow(deprecated)]
7089    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7090    where
7091        S: serde::Serializer,
7092    {
7093        use serde::ser::SerializeStruct;
7094        let mut len = 0;
7095        if !self.fragment_to_table.is_empty() {
7096            len += 1;
7097        }
7098        if !self.worker_slot_mappings.is_empty() {
7099            len += 1;
7100        }
7101        let mut struct_ser = serializer.serialize_struct("meta.GetServingVnodeMappingsResponse", len)?;
7102        if !self.fragment_to_table.is_empty() {
7103            struct_ser.serialize_field("fragmentToTable", &self.fragment_to_table)?;
7104        }
7105        if !self.worker_slot_mappings.is_empty() {
7106            struct_ser.serialize_field("workerSlotMappings", &self.worker_slot_mappings)?;
7107        }
7108        struct_ser.end()
7109    }
7110}
7111impl<'de> serde::Deserialize<'de> for GetServingVnodeMappingsResponse {
7112    #[allow(deprecated)]
7113    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7114    where
7115        D: serde::Deserializer<'de>,
7116    {
7117        const FIELDS: &[&str] = &[
7118            "fragment_to_table",
7119            "fragmentToTable",
7120            "worker_slot_mappings",
7121            "workerSlotMappings",
7122        ];
7123
7124        #[allow(clippy::enum_variant_names)]
7125        enum GeneratedField {
7126            FragmentToTable,
7127            WorkerSlotMappings,
7128        }
7129        impl<'de> serde::Deserialize<'de> for GeneratedField {
7130            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7131            where
7132                D: serde::Deserializer<'de>,
7133            {
7134                struct GeneratedVisitor;
7135
7136                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7137                    type Value = GeneratedField;
7138
7139                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7140                        write!(formatter, "expected one of: {:?}", &FIELDS)
7141                    }
7142
7143                    #[allow(unused_variables)]
7144                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7145                    where
7146                        E: serde::de::Error,
7147                    {
7148                        match value {
7149                            "fragmentToTable" | "fragment_to_table" => Ok(GeneratedField::FragmentToTable),
7150                            "workerSlotMappings" | "worker_slot_mappings" => Ok(GeneratedField::WorkerSlotMappings),
7151                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7152                        }
7153                    }
7154                }
7155                deserializer.deserialize_identifier(GeneratedVisitor)
7156            }
7157        }
7158        struct GeneratedVisitor;
7159        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7160            type Value = GetServingVnodeMappingsResponse;
7161
7162            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7163                formatter.write_str("struct meta.GetServingVnodeMappingsResponse")
7164            }
7165
7166            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetServingVnodeMappingsResponse, V::Error>
7167                where
7168                    V: serde::de::MapAccess<'de>,
7169            {
7170                let mut fragment_to_table__ = None;
7171                let mut worker_slot_mappings__ = None;
7172                while let Some(k) = map_.next_key()? {
7173                    match k {
7174                        GeneratedField::FragmentToTable => {
7175                            if fragment_to_table__.is_some() {
7176                                return Err(serde::de::Error::duplicate_field("fragmentToTable"));
7177                            }
7178                            fragment_to_table__ = Some(
7179                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<u32>>>()?
7180                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
7181                            );
7182                        }
7183                        GeneratedField::WorkerSlotMappings => {
7184                            if worker_slot_mappings__.is_some() {
7185                                return Err(serde::de::Error::duplicate_field("workerSlotMappings"));
7186                            }
7187                            worker_slot_mappings__ = Some(map_.next_value()?);
7188                        }
7189                    }
7190                }
7191                Ok(GetServingVnodeMappingsResponse {
7192                    fragment_to_table: fragment_to_table__.unwrap_or_default(),
7193                    worker_slot_mappings: worker_slot_mappings__.unwrap_or_default(),
7194                })
7195            }
7196        }
7197        deserializer.deserialize_struct("meta.GetServingVnodeMappingsResponse", FIELDS, GeneratedVisitor)
7198    }
7199}
7200impl serde::Serialize for GetSessionParamsRequest {
7201    #[allow(deprecated)]
7202    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7203    where
7204        S: serde::Serializer,
7205    {
7206        use serde::ser::SerializeStruct;
7207        let len = 0;
7208        let struct_ser = serializer.serialize_struct("meta.GetSessionParamsRequest", len)?;
7209        struct_ser.end()
7210    }
7211}
7212impl<'de> serde::Deserialize<'de> for GetSessionParamsRequest {
7213    #[allow(deprecated)]
7214    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7215    where
7216        D: serde::Deserializer<'de>,
7217    {
7218        const FIELDS: &[&str] = &[
7219        ];
7220
7221        #[allow(clippy::enum_variant_names)]
7222        enum GeneratedField {
7223        }
7224        impl<'de> serde::Deserialize<'de> for GeneratedField {
7225            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7226            where
7227                D: serde::Deserializer<'de>,
7228            {
7229                struct GeneratedVisitor;
7230
7231                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7232                    type Value = GeneratedField;
7233
7234                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7235                        write!(formatter, "expected one of: {:?}", &FIELDS)
7236                    }
7237
7238                    #[allow(unused_variables)]
7239                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7240                    where
7241                        E: serde::de::Error,
7242                    {
7243                            Err(serde::de::Error::unknown_field(value, FIELDS))
7244                    }
7245                }
7246                deserializer.deserialize_identifier(GeneratedVisitor)
7247            }
7248        }
7249        struct GeneratedVisitor;
7250        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7251            type Value = GetSessionParamsRequest;
7252
7253            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7254                formatter.write_str("struct meta.GetSessionParamsRequest")
7255            }
7256
7257            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsRequest, V::Error>
7258                where
7259                    V: serde::de::MapAccess<'de>,
7260            {
7261                while map_.next_key::<GeneratedField>()?.is_some() {
7262                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7263                }
7264                Ok(GetSessionParamsRequest {
7265                })
7266            }
7267        }
7268        deserializer.deserialize_struct("meta.GetSessionParamsRequest", FIELDS, GeneratedVisitor)
7269    }
7270}
7271impl serde::Serialize for GetSessionParamsResponse {
7272    #[allow(deprecated)]
7273    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7274    where
7275        S: serde::Serializer,
7276    {
7277        use serde::ser::SerializeStruct;
7278        let mut len = 0;
7279        if !self.params.is_empty() {
7280            len += 1;
7281        }
7282        let mut struct_ser = serializer.serialize_struct("meta.GetSessionParamsResponse", len)?;
7283        if !self.params.is_empty() {
7284            struct_ser.serialize_field("params", &self.params)?;
7285        }
7286        struct_ser.end()
7287    }
7288}
7289impl<'de> serde::Deserialize<'de> for GetSessionParamsResponse {
7290    #[allow(deprecated)]
7291    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7292    where
7293        D: serde::Deserializer<'de>,
7294    {
7295        const FIELDS: &[&str] = &[
7296            "params",
7297        ];
7298
7299        #[allow(clippy::enum_variant_names)]
7300        enum GeneratedField {
7301            Params,
7302        }
7303        impl<'de> serde::Deserialize<'de> for GeneratedField {
7304            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7305            where
7306                D: serde::Deserializer<'de>,
7307            {
7308                struct GeneratedVisitor;
7309
7310                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7311                    type Value = GeneratedField;
7312
7313                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7314                        write!(formatter, "expected one of: {:?}", &FIELDS)
7315                    }
7316
7317                    #[allow(unused_variables)]
7318                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7319                    where
7320                        E: serde::de::Error,
7321                    {
7322                        match value {
7323                            "params" => Ok(GeneratedField::Params),
7324                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7325                        }
7326                    }
7327                }
7328                deserializer.deserialize_identifier(GeneratedVisitor)
7329            }
7330        }
7331        struct GeneratedVisitor;
7332        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7333            type Value = GetSessionParamsResponse;
7334
7335            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7336                formatter.write_str("struct meta.GetSessionParamsResponse")
7337            }
7338
7339            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSessionParamsResponse, V::Error>
7340                where
7341                    V: serde::de::MapAccess<'de>,
7342            {
7343                let mut params__ = None;
7344                while let Some(k) = map_.next_key()? {
7345                    match k {
7346                        GeneratedField::Params => {
7347                            if params__.is_some() {
7348                                return Err(serde::de::Error::duplicate_field("params"));
7349                            }
7350                            params__ = Some(map_.next_value()?);
7351                        }
7352                    }
7353                }
7354                Ok(GetSessionParamsResponse {
7355                    params: params__.unwrap_or_default(),
7356                })
7357            }
7358        }
7359        deserializer.deserialize_struct("meta.GetSessionParamsResponse", FIELDS, GeneratedVisitor)
7360    }
7361}
7362impl serde::Serialize for GetSystemParamsRequest {
7363    #[allow(deprecated)]
7364    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7365    where
7366        S: serde::Serializer,
7367    {
7368        use serde::ser::SerializeStruct;
7369        let len = 0;
7370        let struct_ser = serializer.serialize_struct("meta.GetSystemParamsRequest", len)?;
7371        struct_ser.end()
7372    }
7373}
7374impl<'de> serde::Deserialize<'de> for GetSystemParamsRequest {
7375    #[allow(deprecated)]
7376    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7377    where
7378        D: serde::Deserializer<'de>,
7379    {
7380        const FIELDS: &[&str] = &[
7381        ];
7382
7383        #[allow(clippy::enum_variant_names)]
7384        enum GeneratedField {
7385        }
7386        impl<'de> serde::Deserialize<'de> for GeneratedField {
7387            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7388            where
7389                D: serde::Deserializer<'de>,
7390            {
7391                struct GeneratedVisitor;
7392
7393                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7394                    type Value = GeneratedField;
7395
7396                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7397                        write!(formatter, "expected one of: {:?}", &FIELDS)
7398                    }
7399
7400                    #[allow(unused_variables)]
7401                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7402                    where
7403                        E: serde::de::Error,
7404                    {
7405                            Err(serde::de::Error::unknown_field(value, FIELDS))
7406                    }
7407                }
7408                deserializer.deserialize_identifier(GeneratedVisitor)
7409            }
7410        }
7411        struct GeneratedVisitor;
7412        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7413            type Value = GetSystemParamsRequest;
7414
7415            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7416                formatter.write_str("struct meta.GetSystemParamsRequest")
7417            }
7418
7419            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsRequest, V::Error>
7420                where
7421                    V: serde::de::MapAccess<'de>,
7422            {
7423                while map_.next_key::<GeneratedField>()?.is_some() {
7424                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7425                }
7426                Ok(GetSystemParamsRequest {
7427                })
7428            }
7429        }
7430        deserializer.deserialize_struct("meta.GetSystemParamsRequest", FIELDS, GeneratedVisitor)
7431    }
7432}
7433impl serde::Serialize for GetSystemParamsResponse {
7434    #[allow(deprecated)]
7435    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7436    where
7437        S: serde::Serializer,
7438    {
7439        use serde::ser::SerializeStruct;
7440        let mut len = 0;
7441        if self.params.is_some() {
7442            len += 1;
7443        }
7444        let mut struct_ser = serializer.serialize_struct("meta.GetSystemParamsResponse", len)?;
7445        if let Some(v) = self.params.as_ref() {
7446            struct_ser.serialize_field("params", v)?;
7447        }
7448        struct_ser.end()
7449    }
7450}
7451impl<'de> serde::Deserialize<'de> for GetSystemParamsResponse {
7452    #[allow(deprecated)]
7453    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7454    where
7455        D: serde::Deserializer<'de>,
7456    {
7457        const FIELDS: &[&str] = &[
7458            "params",
7459        ];
7460
7461        #[allow(clippy::enum_variant_names)]
7462        enum GeneratedField {
7463            Params,
7464        }
7465        impl<'de> serde::Deserialize<'de> for GeneratedField {
7466            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7467            where
7468                D: serde::Deserializer<'de>,
7469            {
7470                struct GeneratedVisitor;
7471
7472                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7473                    type Value = GeneratedField;
7474
7475                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7476                        write!(formatter, "expected one of: {:?}", &FIELDS)
7477                    }
7478
7479                    #[allow(unused_variables)]
7480                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7481                    where
7482                        E: serde::de::Error,
7483                    {
7484                        match value {
7485                            "params" => Ok(GeneratedField::Params),
7486                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7487                        }
7488                    }
7489                }
7490                deserializer.deserialize_identifier(GeneratedVisitor)
7491            }
7492        }
7493        struct GeneratedVisitor;
7494        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7495            type Value = GetSystemParamsResponse;
7496
7497            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7498                formatter.write_str("struct meta.GetSystemParamsResponse")
7499            }
7500
7501            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetSystemParamsResponse, V::Error>
7502                where
7503                    V: serde::de::MapAccess<'de>,
7504            {
7505                let mut params__ = None;
7506                while let Some(k) = map_.next_key()? {
7507                    match k {
7508                        GeneratedField::Params => {
7509                            if params__.is_some() {
7510                                return Err(serde::de::Error::duplicate_field("params"));
7511                            }
7512                            params__ = map_.next_value()?;
7513                        }
7514                    }
7515                }
7516                Ok(GetSystemParamsResponse {
7517                    params: params__,
7518                })
7519            }
7520        }
7521        deserializer.deserialize_struct("meta.GetSystemParamsResponse", FIELDS, GeneratedVisitor)
7522    }
7523}
7524impl serde::Serialize for GetTelemetryInfoRequest {
7525    #[allow(deprecated)]
7526    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7527    where
7528        S: serde::Serializer,
7529    {
7530        use serde::ser::SerializeStruct;
7531        let len = 0;
7532        let struct_ser = serializer.serialize_struct("meta.GetTelemetryInfoRequest", len)?;
7533        struct_ser.end()
7534    }
7535}
7536impl<'de> serde::Deserialize<'de> for GetTelemetryInfoRequest {
7537    #[allow(deprecated)]
7538    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7539    where
7540        D: serde::Deserializer<'de>,
7541    {
7542        const FIELDS: &[&str] = &[
7543        ];
7544
7545        #[allow(clippy::enum_variant_names)]
7546        enum GeneratedField {
7547        }
7548        impl<'de> serde::Deserialize<'de> for GeneratedField {
7549            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7550            where
7551                D: serde::Deserializer<'de>,
7552            {
7553                struct GeneratedVisitor;
7554
7555                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7556                    type Value = GeneratedField;
7557
7558                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7559                        write!(formatter, "expected one of: {:?}", &FIELDS)
7560                    }
7561
7562                    #[allow(unused_variables)]
7563                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7564                    where
7565                        E: serde::de::Error,
7566                    {
7567                            Err(serde::de::Error::unknown_field(value, FIELDS))
7568                    }
7569                }
7570                deserializer.deserialize_identifier(GeneratedVisitor)
7571            }
7572        }
7573        struct GeneratedVisitor;
7574        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7575            type Value = GetTelemetryInfoRequest;
7576
7577            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7578                formatter.write_str("struct meta.GetTelemetryInfoRequest")
7579            }
7580
7581            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetTelemetryInfoRequest, V::Error>
7582                where
7583                    V: serde::de::MapAccess<'de>,
7584            {
7585                while map_.next_key::<GeneratedField>()?.is_some() {
7586                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7587                }
7588                Ok(GetTelemetryInfoRequest {
7589                })
7590            }
7591        }
7592        deserializer.deserialize_struct("meta.GetTelemetryInfoRequest", FIELDS, GeneratedVisitor)
7593    }
7594}
7595impl serde::Serialize for HeartbeatRequest {
7596    #[allow(deprecated)]
7597    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7598    where
7599        S: serde::Serializer,
7600    {
7601        use serde::ser::SerializeStruct;
7602        let mut len = 0;
7603        if self.node_id != 0 {
7604            len += 1;
7605        }
7606        let mut struct_ser = serializer.serialize_struct("meta.HeartbeatRequest", len)?;
7607        if self.node_id != 0 {
7608            struct_ser.serialize_field("nodeId", &self.node_id)?;
7609        }
7610        struct_ser.end()
7611    }
7612}
7613impl<'de> serde::Deserialize<'de> for HeartbeatRequest {
7614    #[allow(deprecated)]
7615    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7616    where
7617        D: serde::Deserializer<'de>,
7618    {
7619        const FIELDS: &[&str] = &[
7620            "node_id",
7621            "nodeId",
7622        ];
7623
7624        #[allow(clippy::enum_variant_names)]
7625        enum GeneratedField {
7626            NodeId,
7627        }
7628        impl<'de> serde::Deserialize<'de> for GeneratedField {
7629            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7630            where
7631                D: serde::Deserializer<'de>,
7632            {
7633                struct GeneratedVisitor;
7634
7635                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7636                    type Value = GeneratedField;
7637
7638                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7639                        write!(formatter, "expected one of: {:?}", &FIELDS)
7640                    }
7641
7642                    #[allow(unused_variables)]
7643                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7644                    where
7645                        E: serde::de::Error,
7646                    {
7647                        match value {
7648                            "nodeId" | "node_id" => Ok(GeneratedField::NodeId),
7649                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7650                        }
7651                    }
7652                }
7653                deserializer.deserialize_identifier(GeneratedVisitor)
7654            }
7655        }
7656        struct GeneratedVisitor;
7657        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7658            type Value = HeartbeatRequest;
7659
7660            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7661                formatter.write_str("struct meta.HeartbeatRequest")
7662            }
7663
7664            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatRequest, V::Error>
7665                where
7666                    V: serde::de::MapAccess<'de>,
7667            {
7668                let mut node_id__ = None;
7669                while let Some(k) = map_.next_key()? {
7670                    match k {
7671                        GeneratedField::NodeId => {
7672                            if node_id__.is_some() {
7673                                return Err(serde::de::Error::duplicate_field("nodeId"));
7674                            }
7675                            node_id__ = 
7676                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7677                            ;
7678                        }
7679                    }
7680                }
7681                Ok(HeartbeatRequest {
7682                    node_id: node_id__.unwrap_or_default(),
7683                })
7684            }
7685        }
7686        deserializer.deserialize_struct("meta.HeartbeatRequest", FIELDS, GeneratedVisitor)
7687    }
7688}
7689impl serde::Serialize for HeartbeatResponse {
7690    #[allow(deprecated)]
7691    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7692    where
7693        S: serde::Serializer,
7694    {
7695        use serde::ser::SerializeStruct;
7696        let mut len = 0;
7697        if self.status.is_some() {
7698            len += 1;
7699        }
7700        let mut struct_ser = serializer.serialize_struct("meta.HeartbeatResponse", len)?;
7701        if let Some(v) = self.status.as_ref() {
7702            struct_ser.serialize_field("status", v)?;
7703        }
7704        struct_ser.end()
7705    }
7706}
7707impl<'de> serde::Deserialize<'de> for HeartbeatResponse {
7708    #[allow(deprecated)]
7709    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7710    where
7711        D: serde::Deserializer<'de>,
7712    {
7713        const FIELDS: &[&str] = &[
7714            "status",
7715        ];
7716
7717        #[allow(clippy::enum_variant_names)]
7718        enum GeneratedField {
7719            Status,
7720        }
7721        impl<'de> serde::Deserialize<'de> for GeneratedField {
7722            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7723            where
7724                D: serde::Deserializer<'de>,
7725            {
7726                struct GeneratedVisitor;
7727
7728                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7729                    type Value = GeneratedField;
7730
7731                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7732                        write!(formatter, "expected one of: {:?}", &FIELDS)
7733                    }
7734
7735                    #[allow(unused_variables)]
7736                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7737                    where
7738                        E: serde::de::Error,
7739                    {
7740                        match value {
7741                            "status" => Ok(GeneratedField::Status),
7742                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7743                        }
7744                    }
7745                }
7746                deserializer.deserialize_identifier(GeneratedVisitor)
7747            }
7748        }
7749        struct GeneratedVisitor;
7750        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7751            type Value = HeartbeatResponse;
7752
7753            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7754                formatter.write_str("struct meta.HeartbeatResponse")
7755            }
7756
7757            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HeartbeatResponse, V::Error>
7758                where
7759                    V: serde::de::MapAccess<'de>,
7760            {
7761                let mut status__ = None;
7762                while let Some(k) = map_.next_key()? {
7763                    match k {
7764                        GeneratedField::Status => {
7765                            if status__.is_some() {
7766                                return Err(serde::de::Error::duplicate_field("status"));
7767                            }
7768                            status__ = map_.next_value()?;
7769                        }
7770                    }
7771                }
7772                Ok(HeartbeatResponse {
7773                    status: status__,
7774                })
7775            }
7776        }
7777        deserializer.deserialize_struct("meta.HeartbeatResponse", FIELDS, GeneratedVisitor)
7778    }
7779}
7780impl serde::Serialize for ListActorSplitsRequest {
7781    #[allow(deprecated)]
7782    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7783    where
7784        S: serde::Serializer,
7785    {
7786        use serde::ser::SerializeStruct;
7787        let len = 0;
7788        let struct_ser = serializer.serialize_struct("meta.ListActorSplitsRequest", len)?;
7789        struct_ser.end()
7790    }
7791}
7792impl<'de> serde::Deserialize<'de> for ListActorSplitsRequest {
7793    #[allow(deprecated)]
7794    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7795    where
7796        D: serde::Deserializer<'de>,
7797    {
7798        const FIELDS: &[&str] = &[
7799        ];
7800
7801        #[allow(clippy::enum_variant_names)]
7802        enum GeneratedField {
7803        }
7804        impl<'de> serde::Deserialize<'de> for GeneratedField {
7805            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7806            where
7807                D: serde::Deserializer<'de>,
7808            {
7809                struct GeneratedVisitor;
7810
7811                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7812                    type Value = GeneratedField;
7813
7814                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7815                        write!(formatter, "expected one of: {:?}", &FIELDS)
7816                    }
7817
7818                    #[allow(unused_variables)]
7819                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7820                    where
7821                        E: serde::de::Error,
7822                    {
7823                            Err(serde::de::Error::unknown_field(value, FIELDS))
7824                    }
7825                }
7826                deserializer.deserialize_identifier(GeneratedVisitor)
7827            }
7828        }
7829        struct GeneratedVisitor;
7830        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7831            type Value = ListActorSplitsRequest;
7832
7833            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7834                formatter.write_str("struct meta.ListActorSplitsRequest")
7835            }
7836
7837            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsRequest, V::Error>
7838                where
7839                    V: serde::de::MapAccess<'de>,
7840            {
7841                while map_.next_key::<GeneratedField>()?.is_some() {
7842                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7843                }
7844                Ok(ListActorSplitsRequest {
7845                })
7846            }
7847        }
7848        deserializer.deserialize_struct("meta.ListActorSplitsRequest", FIELDS, GeneratedVisitor)
7849    }
7850}
7851impl serde::Serialize for ListActorSplitsResponse {
7852    #[allow(deprecated)]
7853    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7854    where
7855        S: serde::Serializer,
7856    {
7857        use serde::ser::SerializeStruct;
7858        let mut len = 0;
7859        if !self.actor_splits.is_empty() {
7860            len += 1;
7861        }
7862        let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse", len)?;
7863        if !self.actor_splits.is_empty() {
7864            struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
7865        }
7866        struct_ser.end()
7867    }
7868}
7869impl<'de> serde::Deserialize<'de> for ListActorSplitsResponse {
7870    #[allow(deprecated)]
7871    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7872    where
7873        D: serde::Deserializer<'de>,
7874    {
7875        const FIELDS: &[&str] = &[
7876            "actor_splits",
7877            "actorSplits",
7878        ];
7879
7880        #[allow(clippy::enum_variant_names)]
7881        enum GeneratedField {
7882            ActorSplits,
7883        }
7884        impl<'de> serde::Deserialize<'de> for GeneratedField {
7885            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7886            where
7887                D: serde::Deserializer<'de>,
7888            {
7889                struct GeneratedVisitor;
7890
7891                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7892                    type Value = GeneratedField;
7893
7894                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7895                        write!(formatter, "expected one of: {:?}", &FIELDS)
7896                    }
7897
7898                    #[allow(unused_variables)]
7899                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7900                    where
7901                        E: serde::de::Error,
7902                    {
7903                        match value {
7904                            "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
7905                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7906                        }
7907                    }
7908                }
7909                deserializer.deserialize_identifier(GeneratedVisitor)
7910            }
7911        }
7912        struct GeneratedVisitor;
7913        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7914            type Value = ListActorSplitsResponse;
7915
7916            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7917                formatter.write_str("struct meta.ListActorSplitsResponse")
7918            }
7919
7920            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorSplitsResponse, V::Error>
7921                where
7922                    V: serde::de::MapAccess<'de>,
7923            {
7924                let mut actor_splits__ = None;
7925                while let Some(k) = map_.next_key()? {
7926                    match k {
7927                        GeneratedField::ActorSplits => {
7928                            if actor_splits__.is_some() {
7929                                return Err(serde::de::Error::duplicate_field("actorSplits"));
7930                            }
7931                            actor_splits__ = Some(map_.next_value()?);
7932                        }
7933                    }
7934                }
7935                Ok(ListActorSplitsResponse {
7936                    actor_splits: actor_splits__.unwrap_or_default(),
7937                })
7938            }
7939        }
7940        deserializer.deserialize_struct("meta.ListActorSplitsResponse", FIELDS, GeneratedVisitor)
7941    }
7942}
7943impl serde::Serialize for list_actor_splits_response::ActorSplit {
7944    #[allow(deprecated)]
7945    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7946    where
7947        S: serde::Serializer,
7948    {
7949        use serde::ser::SerializeStruct;
7950        let mut len = 0;
7951        if self.actor_id != 0 {
7952            len += 1;
7953        }
7954        if self.fragment_id != 0 {
7955            len += 1;
7956        }
7957        if self.source_id != 0 {
7958            len += 1;
7959        }
7960        if !self.split_id.is_empty() {
7961            len += 1;
7962        }
7963        if self.fragment_type != 0 {
7964            len += 1;
7965        }
7966        let mut struct_ser = serializer.serialize_struct("meta.ListActorSplitsResponse.ActorSplit", len)?;
7967        if self.actor_id != 0 {
7968            struct_ser.serialize_field("actorId", &self.actor_id)?;
7969        }
7970        if self.fragment_id != 0 {
7971            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
7972        }
7973        if self.source_id != 0 {
7974            struct_ser.serialize_field("sourceId", &self.source_id)?;
7975        }
7976        if !self.split_id.is_empty() {
7977            struct_ser.serialize_field("splitId", &self.split_id)?;
7978        }
7979        if self.fragment_type != 0 {
7980            let v = list_actor_splits_response::FragmentType::try_from(self.fragment_type)
7981                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.fragment_type)))?;
7982            struct_ser.serialize_field("fragmentType", &v)?;
7983        }
7984        struct_ser.end()
7985    }
7986}
7987impl<'de> serde::Deserialize<'de> for list_actor_splits_response::ActorSplit {
7988    #[allow(deprecated)]
7989    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7990    where
7991        D: serde::Deserializer<'de>,
7992    {
7993        const FIELDS: &[&str] = &[
7994            "actor_id",
7995            "actorId",
7996            "fragment_id",
7997            "fragmentId",
7998            "source_id",
7999            "sourceId",
8000            "split_id",
8001            "splitId",
8002            "fragment_type",
8003            "fragmentType",
8004        ];
8005
8006        #[allow(clippy::enum_variant_names)]
8007        enum GeneratedField {
8008            ActorId,
8009            FragmentId,
8010            SourceId,
8011            SplitId,
8012            FragmentType,
8013        }
8014        impl<'de> serde::Deserialize<'de> for GeneratedField {
8015            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8016            where
8017                D: serde::Deserializer<'de>,
8018            {
8019                struct GeneratedVisitor;
8020
8021                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8022                    type Value = GeneratedField;
8023
8024                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8025                        write!(formatter, "expected one of: {:?}", &FIELDS)
8026                    }
8027
8028                    #[allow(unused_variables)]
8029                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8030                    where
8031                        E: serde::de::Error,
8032                    {
8033                        match value {
8034                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
8035                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
8036                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
8037                            "splitId" | "split_id" => Ok(GeneratedField::SplitId),
8038                            "fragmentType" | "fragment_type" => Ok(GeneratedField::FragmentType),
8039                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8040                        }
8041                    }
8042                }
8043                deserializer.deserialize_identifier(GeneratedVisitor)
8044            }
8045        }
8046        struct GeneratedVisitor;
8047        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8048            type Value = list_actor_splits_response::ActorSplit;
8049
8050            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8051                formatter.write_str("struct meta.ListActorSplitsResponse.ActorSplit")
8052            }
8053
8054            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_splits_response::ActorSplit, V::Error>
8055                where
8056                    V: serde::de::MapAccess<'de>,
8057            {
8058                let mut actor_id__ = None;
8059                let mut fragment_id__ = None;
8060                let mut source_id__ = None;
8061                let mut split_id__ = None;
8062                let mut fragment_type__ = None;
8063                while let Some(k) = map_.next_key()? {
8064                    match k {
8065                        GeneratedField::ActorId => {
8066                            if actor_id__.is_some() {
8067                                return Err(serde::de::Error::duplicate_field("actorId"));
8068                            }
8069                            actor_id__ = 
8070                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8071                            ;
8072                        }
8073                        GeneratedField::FragmentId => {
8074                            if fragment_id__.is_some() {
8075                                return Err(serde::de::Error::duplicate_field("fragmentId"));
8076                            }
8077                            fragment_id__ = 
8078                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8079                            ;
8080                        }
8081                        GeneratedField::SourceId => {
8082                            if source_id__.is_some() {
8083                                return Err(serde::de::Error::duplicate_field("sourceId"));
8084                            }
8085                            source_id__ = 
8086                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8087                            ;
8088                        }
8089                        GeneratedField::SplitId => {
8090                            if split_id__.is_some() {
8091                                return Err(serde::de::Error::duplicate_field("splitId"));
8092                            }
8093                            split_id__ = Some(map_.next_value()?);
8094                        }
8095                        GeneratedField::FragmentType => {
8096                            if fragment_type__.is_some() {
8097                                return Err(serde::de::Error::duplicate_field("fragmentType"));
8098                            }
8099                            fragment_type__ = Some(map_.next_value::<list_actor_splits_response::FragmentType>()? as i32);
8100                        }
8101                    }
8102                }
8103                Ok(list_actor_splits_response::ActorSplit {
8104                    actor_id: actor_id__.unwrap_or_default(),
8105                    fragment_id: fragment_id__.unwrap_or_default(),
8106                    source_id: source_id__.unwrap_or_default(),
8107                    split_id: split_id__.unwrap_or_default(),
8108                    fragment_type: fragment_type__.unwrap_or_default(),
8109                })
8110            }
8111        }
8112        deserializer.deserialize_struct("meta.ListActorSplitsResponse.ActorSplit", FIELDS, GeneratedVisitor)
8113    }
8114}
8115impl serde::Serialize for list_actor_splits_response::FragmentType {
8116    #[allow(deprecated)]
8117    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8118    where
8119        S: serde::Serializer,
8120    {
8121        let variant = match self {
8122            Self::Unspecified => "UNSPECIFIED",
8123            Self::NonSharedSource => "NON_SHARED_SOURCE",
8124            Self::SharedSource => "SHARED_SOURCE",
8125            Self::SharedSourceBackfill => "SHARED_SOURCE_BACKFILL",
8126        };
8127        serializer.serialize_str(variant)
8128    }
8129}
8130impl<'de> serde::Deserialize<'de> for list_actor_splits_response::FragmentType {
8131    #[allow(deprecated)]
8132    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8133    where
8134        D: serde::Deserializer<'de>,
8135    {
8136        const FIELDS: &[&str] = &[
8137            "UNSPECIFIED",
8138            "NON_SHARED_SOURCE",
8139            "SHARED_SOURCE",
8140            "SHARED_SOURCE_BACKFILL",
8141        ];
8142
8143        struct GeneratedVisitor;
8144
8145        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8146            type Value = list_actor_splits_response::FragmentType;
8147
8148            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8149                write!(formatter, "expected one of: {:?}", &FIELDS)
8150            }
8151
8152            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8153            where
8154                E: serde::de::Error,
8155            {
8156                i32::try_from(v)
8157                    .ok()
8158                    .and_then(|x| x.try_into().ok())
8159                    .ok_or_else(|| {
8160                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8161                    })
8162            }
8163
8164            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8165            where
8166                E: serde::de::Error,
8167            {
8168                i32::try_from(v)
8169                    .ok()
8170                    .and_then(|x| x.try_into().ok())
8171                    .ok_or_else(|| {
8172                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8173                    })
8174            }
8175
8176            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8177            where
8178                E: serde::de::Error,
8179            {
8180                match value {
8181                    "UNSPECIFIED" => Ok(list_actor_splits_response::FragmentType::Unspecified),
8182                    "NON_SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::NonSharedSource),
8183                    "SHARED_SOURCE" => Ok(list_actor_splits_response::FragmentType::SharedSource),
8184                    "SHARED_SOURCE_BACKFILL" => Ok(list_actor_splits_response::FragmentType::SharedSourceBackfill),
8185                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8186                }
8187            }
8188        }
8189        deserializer.deserialize_any(GeneratedVisitor)
8190    }
8191}
8192impl serde::Serialize for ListActorStatesRequest {
8193    #[allow(deprecated)]
8194    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8195    where
8196        S: serde::Serializer,
8197    {
8198        use serde::ser::SerializeStruct;
8199        let len = 0;
8200        let struct_ser = serializer.serialize_struct("meta.ListActorStatesRequest", len)?;
8201        struct_ser.end()
8202    }
8203}
8204impl<'de> serde::Deserialize<'de> for ListActorStatesRequest {
8205    #[allow(deprecated)]
8206    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8207    where
8208        D: serde::Deserializer<'de>,
8209    {
8210        const FIELDS: &[&str] = &[
8211        ];
8212
8213        #[allow(clippy::enum_variant_names)]
8214        enum GeneratedField {
8215        }
8216        impl<'de> serde::Deserialize<'de> for GeneratedField {
8217            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8218            where
8219                D: serde::Deserializer<'de>,
8220            {
8221                struct GeneratedVisitor;
8222
8223                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8224                    type Value = GeneratedField;
8225
8226                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8227                        write!(formatter, "expected one of: {:?}", &FIELDS)
8228                    }
8229
8230                    #[allow(unused_variables)]
8231                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8232                    where
8233                        E: serde::de::Error,
8234                    {
8235                            Err(serde::de::Error::unknown_field(value, FIELDS))
8236                    }
8237                }
8238                deserializer.deserialize_identifier(GeneratedVisitor)
8239            }
8240        }
8241        struct GeneratedVisitor;
8242        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8243            type Value = ListActorStatesRequest;
8244
8245            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8246                formatter.write_str("struct meta.ListActorStatesRequest")
8247            }
8248
8249            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesRequest, V::Error>
8250                where
8251                    V: serde::de::MapAccess<'de>,
8252            {
8253                while map_.next_key::<GeneratedField>()?.is_some() {
8254                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8255                }
8256                Ok(ListActorStatesRequest {
8257                })
8258            }
8259        }
8260        deserializer.deserialize_struct("meta.ListActorStatesRequest", FIELDS, GeneratedVisitor)
8261    }
8262}
8263impl serde::Serialize for ListActorStatesResponse {
8264    #[allow(deprecated)]
8265    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8266    where
8267        S: serde::Serializer,
8268    {
8269        use serde::ser::SerializeStruct;
8270        let mut len = 0;
8271        if !self.states.is_empty() {
8272            len += 1;
8273        }
8274        let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse", len)?;
8275        if !self.states.is_empty() {
8276            struct_ser.serialize_field("states", &self.states)?;
8277        }
8278        struct_ser.end()
8279    }
8280}
8281impl<'de> serde::Deserialize<'de> for ListActorStatesResponse {
8282    #[allow(deprecated)]
8283    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8284    where
8285        D: serde::Deserializer<'de>,
8286    {
8287        const FIELDS: &[&str] = &[
8288            "states",
8289        ];
8290
8291        #[allow(clippy::enum_variant_names)]
8292        enum GeneratedField {
8293            States,
8294        }
8295        impl<'de> serde::Deserialize<'de> for GeneratedField {
8296            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8297            where
8298                D: serde::Deserializer<'de>,
8299            {
8300                struct GeneratedVisitor;
8301
8302                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8303                    type Value = GeneratedField;
8304
8305                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8306                        write!(formatter, "expected one of: {:?}", &FIELDS)
8307                    }
8308
8309                    #[allow(unused_variables)]
8310                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8311                    where
8312                        E: serde::de::Error,
8313                    {
8314                        match value {
8315                            "states" => Ok(GeneratedField::States),
8316                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8317                        }
8318                    }
8319                }
8320                deserializer.deserialize_identifier(GeneratedVisitor)
8321            }
8322        }
8323        struct GeneratedVisitor;
8324        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8325            type Value = ListActorStatesResponse;
8326
8327            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8328                formatter.write_str("struct meta.ListActorStatesResponse")
8329            }
8330
8331            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListActorStatesResponse, V::Error>
8332                where
8333                    V: serde::de::MapAccess<'de>,
8334            {
8335                let mut states__ = None;
8336                while let Some(k) = map_.next_key()? {
8337                    match k {
8338                        GeneratedField::States => {
8339                            if states__.is_some() {
8340                                return Err(serde::de::Error::duplicate_field("states"));
8341                            }
8342                            states__ = Some(map_.next_value()?);
8343                        }
8344                    }
8345                }
8346                Ok(ListActorStatesResponse {
8347                    states: states__.unwrap_or_default(),
8348                })
8349            }
8350        }
8351        deserializer.deserialize_struct("meta.ListActorStatesResponse", FIELDS, GeneratedVisitor)
8352    }
8353}
8354impl serde::Serialize for list_actor_states_response::ActorState {
8355    #[allow(deprecated)]
8356    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8357    where
8358        S: serde::Serializer,
8359    {
8360        use serde::ser::SerializeStruct;
8361        let mut len = 0;
8362        if self.actor_id != 0 {
8363            len += 1;
8364        }
8365        if self.fragment_id != 0 {
8366            len += 1;
8367        }
8368        if self.state != 0 {
8369            len += 1;
8370        }
8371        if self.worker_id != 0 {
8372            len += 1;
8373        }
8374        let mut struct_ser = serializer.serialize_struct("meta.ListActorStatesResponse.ActorState", len)?;
8375        if self.actor_id != 0 {
8376            struct_ser.serialize_field("actorId", &self.actor_id)?;
8377        }
8378        if self.fragment_id != 0 {
8379            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
8380        }
8381        if self.state != 0 {
8382            let v = table_fragments::actor_status::ActorState::try_from(self.state)
8383                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
8384            struct_ser.serialize_field("state", &v)?;
8385        }
8386        if self.worker_id != 0 {
8387            struct_ser.serialize_field("workerId", &self.worker_id)?;
8388        }
8389        struct_ser.end()
8390    }
8391}
8392impl<'de> serde::Deserialize<'de> for list_actor_states_response::ActorState {
8393    #[allow(deprecated)]
8394    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8395    where
8396        D: serde::Deserializer<'de>,
8397    {
8398        const FIELDS: &[&str] = &[
8399            "actor_id",
8400            "actorId",
8401            "fragment_id",
8402            "fragmentId",
8403            "state",
8404            "worker_id",
8405            "workerId",
8406        ];
8407
8408        #[allow(clippy::enum_variant_names)]
8409        enum GeneratedField {
8410            ActorId,
8411            FragmentId,
8412            State,
8413            WorkerId,
8414        }
8415        impl<'de> serde::Deserialize<'de> for GeneratedField {
8416            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8417            where
8418                D: serde::Deserializer<'de>,
8419            {
8420                struct GeneratedVisitor;
8421
8422                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8423                    type Value = GeneratedField;
8424
8425                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8426                        write!(formatter, "expected one of: {:?}", &FIELDS)
8427                    }
8428
8429                    #[allow(unused_variables)]
8430                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8431                    where
8432                        E: serde::de::Error,
8433                    {
8434                        match value {
8435                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
8436                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
8437                            "state" => Ok(GeneratedField::State),
8438                            "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
8439                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8440                        }
8441                    }
8442                }
8443                deserializer.deserialize_identifier(GeneratedVisitor)
8444            }
8445        }
8446        struct GeneratedVisitor;
8447        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8448            type Value = list_actor_states_response::ActorState;
8449
8450            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8451                formatter.write_str("struct meta.ListActorStatesResponse.ActorState")
8452            }
8453
8454            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_actor_states_response::ActorState, V::Error>
8455                where
8456                    V: serde::de::MapAccess<'de>,
8457            {
8458                let mut actor_id__ = None;
8459                let mut fragment_id__ = None;
8460                let mut state__ = None;
8461                let mut worker_id__ = None;
8462                while let Some(k) = map_.next_key()? {
8463                    match k {
8464                        GeneratedField::ActorId => {
8465                            if actor_id__.is_some() {
8466                                return Err(serde::de::Error::duplicate_field("actorId"));
8467                            }
8468                            actor_id__ = 
8469                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8470                            ;
8471                        }
8472                        GeneratedField::FragmentId => {
8473                            if fragment_id__.is_some() {
8474                                return Err(serde::de::Error::duplicate_field("fragmentId"));
8475                            }
8476                            fragment_id__ = 
8477                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8478                            ;
8479                        }
8480                        GeneratedField::State => {
8481                            if state__.is_some() {
8482                                return Err(serde::de::Error::duplicate_field("state"));
8483                            }
8484                            state__ = Some(map_.next_value::<table_fragments::actor_status::ActorState>()? as i32);
8485                        }
8486                        GeneratedField::WorkerId => {
8487                            if worker_id__.is_some() {
8488                                return Err(serde::de::Error::duplicate_field("workerId"));
8489                            }
8490                            worker_id__ = 
8491                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8492                            ;
8493                        }
8494                    }
8495                }
8496                Ok(list_actor_states_response::ActorState {
8497                    actor_id: actor_id__.unwrap_or_default(),
8498                    fragment_id: fragment_id__.unwrap_or_default(),
8499                    state: state__.unwrap_or_default(),
8500                    worker_id: worker_id__.unwrap_or_default(),
8501                })
8502            }
8503        }
8504        deserializer.deserialize_struct("meta.ListActorStatesResponse.ActorState", FIELDS, GeneratedVisitor)
8505    }
8506}
8507impl serde::Serialize for ListAllNodesRequest {
8508    #[allow(deprecated)]
8509    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8510    where
8511        S: serde::Serializer,
8512    {
8513        use serde::ser::SerializeStruct;
8514        let mut len = 0;
8515        if self.worker_type.is_some() {
8516            len += 1;
8517        }
8518        if self.include_starting_nodes {
8519            len += 1;
8520        }
8521        let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesRequest", len)?;
8522        if let Some(v) = self.worker_type.as_ref() {
8523            let v = super::common::WorkerType::try_from(*v)
8524                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", *v)))?;
8525            struct_ser.serialize_field("workerType", &v)?;
8526        }
8527        if self.include_starting_nodes {
8528            struct_ser.serialize_field("includeStartingNodes", &self.include_starting_nodes)?;
8529        }
8530        struct_ser.end()
8531    }
8532}
8533impl<'de> serde::Deserialize<'de> for ListAllNodesRequest {
8534    #[allow(deprecated)]
8535    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8536    where
8537        D: serde::Deserializer<'de>,
8538    {
8539        const FIELDS: &[&str] = &[
8540            "worker_type",
8541            "workerType",
8542            "include_starting_nodes",
8543            "includeStartingNodes",
8544        ];
8545
8546        #[allow(clippy::enum_variant_names)]
8547        enum GeneratedField {
8548            WorkerType,
8549            IncludeStartingNodes,
8550        }
8551        impl<'de> serde::Deserialize<'de> for GeneratedField {
8552            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8553            where
8554                D: serde::Deserializer<'de>,
8555            {
8556                struct GeneratedVisitor;
8557
8558                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8559                    type Value = GeneratedField;
8560
8561                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8562                        write!(formatter, "expected one of: {:?}", &FIELDS)
8563                    }
8564
8565                    #[allow(unused_variables)]
8566                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8567                    where
8568                        E: serde::de::Error,
8569                    {
8570                        match value {
8571                            "workerType" | "worker_type" => Ok(GeneratedField::WorkerType),
8572                            "includeStartingNodes" | "include_starting_nodes" => Ok(GeneratedField::IncludeStartingNodes),
8573                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8574                        }
8575                    }
8576                }
8577                deserializer.deserialize_identifier(GeneratedVisitor)
8578            }
8579        }
8580        struct GeneratedVisitor;
8581        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8582            type Value = ListAllNodesRequest;
8583
8584            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8585                formatter.write_str("struct meta.ListAllNodesRequest")
8586            }
8587
8588            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesRequest, V::Error>
8589                where
8590                    V: serde::de::MapAccess<'de>,
8591            {
8592                let mut worker_type__ = None;
8593                let mut include_starting_nodes__ = None;
8594                while let Some(k) = map_.next_key()? {
8595                    match k {
8596                        GeneratedField::WorkerType => {
8597                            if worker_type__.is_some() {
8598                                return Err(serde::de::Error::duplicate_field("workerType"));
8599                            }
8600                            worker_type__ = map_.next_value::<::std::option::Option<super::common::WorkerType>>()?.map(|x| x as i32);
8601                        }
8602                        GeneratedField::IncludeStartingNodes => {
8603                            if include_starting_nodes__.is_some() {
8604                                return Err(serde::de::Error::duplicate_field("includeStartingNodes"));
8605                            }
8606                            include_starting_nodes__ = Some(map_.next_value()?);
8607                        }
8608                    }
8609                }
8610                Ok(ListAllNodesRequest {
8611                    worker_type: worker_type__,
8612                    include_starting_nodes: include_starting_nodes__.unwrap_or_default(),
8613                })
8614            }
8615        }
8616        deserializer.deserialize_struct("meta.ListAllNodesRequest", FIELDS, GeneratedVisitor)
8617    }
8618}
8619impl serde::Serialize for ListAllNodesResponse {
8620    #[allow(deprecated)]
8621    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8622    where
8623        S: serde::Serializer,
8624    {
8625        use serde::ser::SerializeStruct;
8626        let mut len = 0;
8627        if self.status.is_some() {
8628            len += 1;
8629        }
8630        if !self.nodes.is_empty() {
8631            len += 1;
8632        }
8633        let mut struct_ser = serializer.serialize_struct("meta.ListAllNodesResponse", len)?;
8634        if let Some(v) = self.status.as_ref() {
8635            struct_ser.serialize_field("status", v)?;
8636        }
8637        if !self.nodes.is_empty() {
8638            struct_ser.serialize_field("nodes", &self.nodes)?;
8639        }
8640        struct_ser.end()
8641    }
8642}
8643impl<'de> serde::Deserialize<'de> for ListAllNodesResponse {
8644    #[allow(deprecated)]
8645    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8646    where
8647        D: serde::Deserializer<'de>,
8648    {
8649        const FIELDS: &[&str] = &[
8650            "status",
8651            "nodes",
8652        ];
8653
8654        #[allow(clippy::enum_variant_names)]
8655        enum GeneratedField {
8656            Status,
8657            Nodes,
8658        }
8659        impl<'de> serde::Deserialize<'de> for GeneratedField {
8660            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8661            where
8662                D: serde::Deserializer<'de>,
8663            {
8664                struct GeneratedVisitor;
8665
8666                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8667                    type Value = GeneratedField;
8668
8669                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8670                        write!(formatter, "expected one of: {:?}", &FIELDS)
8671                    }
8672
8673                    #[allow(unused_variables)]
8674                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8675                    where
8676                        E: serde::de::Error,
8677                    {
8678                        match value {
8679                            "status" => Ok(GeneratedField::Status),
8680                            "nodes" => Ok(GeneratedField::Nodes),
8681                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8682                        }
8683                    }
8684                }
8685                deserializer.deserialize_identifier(GeneratedVisitor)
8686            }
8687        }
8688        struct GeneratedVisitor;
8689        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8690            type Value = ListAllNodesResponse;
8691
8692            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8693                formatter.write_str("struct meta.ListAllNodesResponse")
8694            }
8695
8696            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListAllNodesResponse, V::Error>
8697                where
8698                    V: serde::de::MapAccess<'de>,
8699            {
8700                let mut status__ = None;
8701                let mut nodes__ = None;
8702                while let Some(k) = map_.next_key()? {
8703                    match k {
8704                        GeneratedField::Status => {
8705                            if status__.is_some() {
8706                                return Err(serde::de::Error::duplicate_field("status"));
8707                            }
8708                            status__ = map_.next_value()?;
8709                        }
8710                        GeneratedField::Nodes => {
8711                            if nodes__.is_some() {
8712                                return Err(serde::de::Error::duplicate_field("nodes"));
8713                            }
8714                            nodes__ = Some(map_.next_value()?);
8715                        }
8716                    }
8717                }
8718                Ok(ListAllNodesResponse {
8719                    status: status__,
8720                    nodes: nodes__.unwrap_or_default(),
8721                })
8722            }
8723        }
8724        deserializer.deserialize_struct("meta.ListAllNodesResponse", FIELDS, GeneratedVisitor)
8725    }
8726}
8727impl serde::Serialize for ListCdcProgressRequest {
8728    #[allow(deprecated)]
8729    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8730    where
8731        S: serde::Serializer,
8732    {
8733        use serde::ser::SerializeStruct;
8734        let len = 0;
8735        let struct_ser = serializer.serialize_struct("meta.ListCdcProgressRequest", len)?;
8736        struct_ser.end()
8737    }
8738}
8739impl<'de> serde::Deserialize<'de> for ListCdcProgressRequest {
8740    #[allow(deprecated)]
8741    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8742    where
8743        D: serde::Deserializer<'de>,
8744    {
8745        const FIELDS: &[&str] = &[
8746        ];
8747
8748        #[allow(clippy::enum_variant_names)]
8749        enum GeneratedField {
8750        }
8751        impl<'de> serde::Deserialize<'de> for GeneratedField {
8752            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8753            where
8754                D: serde::Deserializer<'de>,
8755            {
8756                struct GeneratedVisitor;
8757
8758                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8759                    type Value = GeneratedField;
8760
8761                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8762                        write!(formatter, "expected one of: {:?}", &FIELDS)
8763                    }
8764
8765                    #[allow(unused_variables)]
8766                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8767                    where
8768                        E: serde::de::Error,
8769                    {
8770                            Err(serde::de::Error::unknown_field(value, FIELDS))
8771                    }
8772                }
8773                deserializer.deserialize_identifier(GeneratedVisitor)
8774            }
8775        }
8776        struct GeneratedVisitor;
8777        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8778            type Value = ListCdcProgressRequest;
8779
8780            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8781                formatter.write_str("struct meta.ListCdcProgressRequest")
8782            }
8783
8784            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressRequest, V::Error>
8785                where
8786                    V: serde::de::MapAccess<'de>,
8787            {
8788                while map_.next_key::<GeneratedField>()?.is_some() {
8789                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8790                }
8791                Ok(ListCdcProgressRequest {
8792                })
8793            }
8794        }
8795        deserializer.deserialize_struct("meta.ListCdcProgressRequest", FIELDS, GeneratedVisitor)
8796    }
8797}
8798impl serde::Serialize for ListCdcProgressResponse {
8799    #[allow(deprecated)]
8800    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8801    where
8802        S: serde::Serializer,
8803    {
8804        use serde::ser::SerializeStruct;
8805        let mut len = 0;
8806        if !self.cdc_progress.is_empty() {
8807            len += 1;
8808        }
8809        let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse", len)?;
8810        if !self.cdc_progress.is_empty() {
8811            struct_ser.serialize_field("cdcProgress", &self.cdc_progress)?;
8812        }
8813        struct_ser.end()
8814    }
8815}
8816impl<'de> serde::Deserialize<'de> for ListCdcProgressResponse {
8817    #[allow(deprecated)]
8818    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8819    where
8820        D: serde::Deserializer<'de>,
8821    {
8822        const FIELDS: &[&str] = &[
8823            "cdc_progress",
8824            "cdcProgress",
8825        ];
8826
8827        #[allow(clippy::enum_variant_names)]
8828        enum GeneratedField {
8829            CdcProgress,
8830        }
8831        impl<'de> serde::Deserialize<'de> for GeneratedField {
8832            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8833            where
8834                D: serde::Deserializer<'de>,
8835            {
8836                struct GeneratedVisitor;
8837
8838                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8839                    type Value = GeneratedField;
8840
8841                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8842                        write!(formatter, "expected one of: {:?}", &FIELDS)
8843                    }
8844
8845                    #[allow(unused_variables)]
8846                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8847                    where
8848                        E: serde::de::Error,
8849                    {
8850                        match value {
8851                            "cdcProgress" | "cdc_progress" => Ok(GeneratedField::CdcProgress),
8852                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8853                        }
8854                    }
8855                }
8856                deserializer.deserialize_identifier(GeneratedVisitor)
8857            }
8858        }
8859        struct GeneratedVisitor;
8860        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8861            type Value = ListCdcProgressResponse;
8862
8863            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8864                formatter.write_str("struct meta.ListCdcProgressResponse")
8865            }
8866
8867            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCdcProgressResponse, V::Error>
8868                where
8869                    V: serde::de::MapAccess<'de>,
8870            {
8871                let mut cdc_progress__ = None;
8872                while let Some(k) = map_.next_key()? {
8873                    match k {
8874                        GeneratedField::CdcProgress => {
8875                            if cdc_progress__.is_some() {
8876                                return Err(serde::de::Error::duplicate_field("cdcProgress"));
8877                            }
8878                            cdc_progress__ = Some(
8879                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8880                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
8881                            );
8882                        }
8883                    }
8884                }
8885                Ok(ListCdcProgressResponse {
8886                    cdc_progress: cdc_progress__.unwrap_or_default(),
8887                })
8888            }
8889        }
8890        deserializer.deserialize_struct("meta.ListCdcProgressResponse", FIELDS, GeneratedVisitor)
8891    }
8892}
8893impl serde::Serialize for list_cdc_progress_response::CdcProgress {
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 mut len = 0;
8901        if self.split_total_count != 0 {
8902            len += 1;
8903        }
8904        if self.split_backfilled_count != 0 {
8905            len += 1;
8906        }
8907        if self.split_completed_count != 0 {
8908            len += 1;
8909        }
8910        let mut struct_ser = serializer.serialize_struct("meta.ListCdcProgressResponse.CdcProgress", len)?;
8911        if self.split_total_count != 0 {
8912            #[allow(clippy::needless_borrow)]
8913            #[allow(clippy::needless_borrows_for_generic_args)]
8914            struct_ser.serialize_field("splitTotalCount", ToString::to_string(&self.split_total_count).as_str())?;
8915        }
8916        if self.split_backfilled_count != 0 {
8917            #[allow(clippy::needless_borrow)]
8918            #[allow(clippy::needless_borrows_for_generic_args)]
8919            struct_ser.serialize_field("splitBackfilledCount", ToString::to_string(&self.split_backfilled_count).as_str())?;
8920        }
8921        if self.split_completed_count != 0 {
8922            #[allow(clippy::needless_borrow)]
8923            #[allow(clippy::needless_borrows_for_generic_args)]
8924            struct_ser.serialize_field("splitCompletedCount", ToString::to_string(&self.split_completed_count).as_str())?;
8925        }
8926        struct_ser.end()
8927    }
8928}
8929impl<'de> serde::Deserialize<'de> for list_cdc_progress_response::CdcProgress {
8930    #[allow(deprecated)]
8931    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8932    where
8933        D: serde::Deserializer<'de>,
8934    {
8935        const FIELDS: &[&str] = &[
8936            "split_total_count",
8937            "splitTotalCount",
8938            "split_backfilled_count",
8939            "splitBackfilledCount",
8940            "split_completed_count",
8941            "splitCompletedCount",
8942        ];
8943
8944        #[allow(clippy::enum_variant_names)]
8945        enum GeneratedField {
8946            SplitTotalCount,
8947            SplitBackfilledCount,
8948            SplitCompletedCount,
8949        }
8950        impl<'de> serde::Deserialize<'de> for GeneratedField {
8951            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8952            where
8953                D: serde::Deserializer<'de>,
8954            {
8955                struct GeneratedVisitor;
8956
8957                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8958                    type Value = GeneratedField;
8959
8960                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8961                        write!(formatter, "expected one of: {:?}", &FIELDS)
8962                    }
8963
8964                    #[allow(unused_variables)]
8965                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8966                    where
8967                        E: serde::de::Error,
8968                    {
8969                        match value {
8970                            "splitTotalCount" | "split_total_count" => Ok(GeneratedField::SplitTotalCount),
8971                            "splitBackfilledCount" | "split_backfilled_count" => Ok(GeneratedField::SplitBackfilledCount),
8972                            "splitCompletedCount" | "split_completed_count" => Ok(GeneratedField::SplitCompletedCount),
8973                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8974                        }
8975                    }
8976                }
8977                deserializer.deserialize_identifier(GeneratedVisitor)
8978            }
8979        }
8980        struct GeneratedVisitor;
8981        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8982            type Value = list_cdc_progress_response::CdcProgress;
8983
8984            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8985                formatter.write_str("struct meta.ListCdcProgressResponse.CdcProgress")
8986            }
8987
8988            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_cdc_progress_response::CdcProgress, V::Error>
8989                where
8990                    V: serde::de::MapAccess<'de>,
8991            {
8992                let mut split_total_count__ = None;
8993                let mut split_backfilled_count__ = None;
8994                let mut split_completed_count__ = None;
8995                while let Some(k) = map_.next_key()? {
8996                    match k {
8997                        GeneratedField::SplitTotalCount => {
8998                            if split_total_count__.is_some() {
8999                                return Err(serde::de::Error::duplicate_field("splitTotalCount"));
9000                            }
9001                            split_total_count__ = 
9002                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9003                            ;
9004                        }
9005                        GeneratedField::SplitBackfilledCount => {
9006                            if split_backfilled_count__.is_some() {
9007                                return Err(serde::de::Error::duplicate_field("splitBackfilledCount"));
9008                            }
9009                            split_backfilled_count__ = 
9010                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9011                            ;
9012                        }
9013                        GeneratedField::SplitCompletedCount => {
9014                            if split_completed_count__.is_some() {
9015                                return Err(serde::de::Error::duplicate_field("splitCompletedCount"));
9016                            }
9017                            split_completed_count__ = 
9018                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9019                            ;
9020                        }
9021                    }
9022                }
9023                Ok(list_cdc_progress_response::CdcProgress {
9024                    split_total_count: split_total_count__.unwrap_or_default(),
9025                    split_backfilled_count: split_backfilled_count__.unwrap_or_default(),
9026                    split_completed_count: split_completed_count__.unwrap_or_default(),
9027                })
9028            }
9029        }
9030        deserializer.deserialize_struct("meta.ListCdcProgressResponse.CdcProgress", FIELDS, GeneratedVisitor)
9031    }
9032}
9033impl serde::Serialize for ListCreatingFragmentDistributionRequest {
9034    #[allow(deprecated)]
9035    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9036    where
9037        S: serde::Serializer,
9038    {
9039        use serde::ser::SerializeStruct;
9040        let len = 0;
9041        let struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionRequest", len)?;
9042        struct_ser.end()
9043    }
9044}
9045impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionRequest {
9046    #[allow(deprecated)]
9047    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9048    where
9049        D: serde::Deserializer<'de>,
9050    {
9051        const FIELDS: &[&str] = &[
9052        ];
9053
9054        #[allow(clippy::enum_variant_names)]
9055        enum GeneratedField {
9056        }
9057        impl<'de> serde::Deserialize<'de> for GeneratedField {
9058            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9059            where
9060                D: serde::Deserializer<'de>,
9061            {
9062                struct GeneratedVisitor;
9063
9064                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9065                    type Value = GeneratedField;
9066
9067                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9068                        write!(formatter, "expected one of: {:?}", &FIELDS)
9069                    }
9070
9071                    #[allow(unused_variables)]
9072                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9073                    where
9074                        E: serde::de::Error,
9075                    {
9076                            Err(serde::de::Error::unknown_field(value, FIELDS))
9077                    }
9078                }
9079                deserializer.deserialize_identifier(GeneratedVisitor)
9080            }
9081        }
9082        struct GeneratedVisitor;
9083        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9084            type Value = ListCreatingFragmentDistributionRequest;
9085
9086            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9087                formatter.write_str("struct meta.ListCreatingFragmentDistributionRequest")
9088            }
9089
9090            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionRequest, V::Error>
9091                where
9092                    V: serde::de::MapAccess<'de>,
9093            {
9094                while map_.next_key::<GeneratedField>()?.is_some() {
9095                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9096                }
9097                Ok(ListCreatingFragmentDistributionRequest {
9098                })
9099            }
9100        }
9101        deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionRequest", FIELDS, GeneratedVisitor)
9102    }
9103}
9104impl serde::Serialize for ListCreatingFragmentDistributionResponse {
9105    #[allow(deprecated)]
9106    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9107    where
9108        S: serde::Serializer,
9109    {
9110        use serde::ser::SerializeStruct;
9111        let mut len = 0;
9112        if !self.distributions.is_empty() {
9113            len += 1;
9114        }
9115        let mut struct_ser = serializer.serialize_struct("meta.ListCreatingFragmentDistributionResponse", len)?;
9116        if !self.distributions.is_empty() {
9117            struct_ser.serialize_field("distributions", &self.distributions)?;
9118        }
9119        struct_ser.end()
9120    }
9121}
9122impl<'de> serde::Deserialize<'de> for ListCreatingFragmentDistributionResponse {
9123    #[allow(deprecated)]
9124    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9125    where
9126        D: serde::Deserializer<'de>,
9127    {
9128        const FIELDS: &[&str] = &[
9129            "distributions",
9130        ];
9131
9132        #[allow(clippy::enum_variant_names)]
9133        enum GeneratedField {
9134            Distributions,
9135        }
9136        impl<'de> serde::Deserialize<'de> for GeneratedField {
9137            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9138            where
9139                D: serde::Deserializer<'de>,
9140            {
9141                struct GeneratedVisitor;
9142
9143                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9144                    type Value = GeneratedField;
9145
9146                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9147                        write!(formatter, "expected one of: {:?}", &FIELDS)
9148                    }
9149
9150                    #[allow(unused_variables)]
9151                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9152                    where
9153                        E: serde::de::Error,
9154                    {
9155                        match value {
9156                            "distributions" => Ok(GeneratedField::Distributions),
9157                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9158                        }
9159                    }
9160                }
9161                deserializer.deserialize_identifier(GeneratedVisitor)
9162            }
9163        }
9164        struct GeneratedVisitor;
9165        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9166            type Value = ListCreatingFragmentDistributionResponse;
9167
9168            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9169                formatter.write_str("struct meta.ListCreatingFragmentDistributionResponse")
9170            }
9171
9172            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListCreatingFragmentDistributionResponse, V::Error>
9173                where
9174                    V: serde::de::MapAccess<'de>,
9175            {
9176                let mut distributions__ = None;
9177                while let Some(k) = map_.next_key()? {
9178                    match k {
9179                        GeneratedField::Distributions => {
9180                            if distributions__.is_some() {
9181                                return Err(serde::de::Error::duplicate_field("distributions"));
9182                            }
9183                            distributions__ = Some(map_.next_value()?);
9184                        }
9185                    }
9186                }
9187                Ok(ListCreatingFragmentDistributionResponse {
9188                    distributions: distributions__.unwrap_or_default(),
9189                })
9190            }
9191        }
9192        deserializer.deserialize_struct("meta.ListCreatingFragmentDistributionResponse", FIELDS, GeneratedVisitor)
9193    }
9194}
9195impl serde::Serialize for ListEventLogRequest {
9196    #[allow(deprecated)]
9197    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9198    where
9199        S: serde::Serializer,
9200    {
9201        use serde::ser::SerializeStruct;
9202        let len = 0;
9203        let struct_ser = serializer.serialize_struct("meta.ListEventLogRequest", len)?;
9204        struct_ser.end()
9205    }
9206}
9207impl<'de> serde::Deserialize<'de> for ListEventLogRequest {
9208    #[allow(deprecated)]
9209    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9210    where
9211        D: serde::Deserializer<'de>,
9212    {
9213        const FIELDS: &[&str] = &[
9214        ];
9215
9216        #[allow(clippy::enum_variant_names)]
9217        enum GeneratedField {
9218        }
9219        impl<'de> serde::Deserialize<'de> for GeneratedField {
9220            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9221            where
9222                D: serde::Deserializer<'de>,
9223            {
9224                struct GeneratedVisitor;
9225
9226                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9227                    type Value = GeneratedField;
9228
9229                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9230                        write!(formatter, "expected one of: {:?}", &FIELDS)
9231                    }
9232
9233                    #[allow(unused_variables)]
9234                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9235                    where
9236                        E: serde::de::Error,
9237                    {
9238                            Err(serde::de::Error::unknown_field(value, FIELDS))
9239                    }
9240                }
9241                deserializer.deserialize_identifier(GeneratedVisitor)
9242            }
9243        }
9244        struct GeneratedVisitor;
9245        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9246            type Value = ListEventLogRequest;
9247
9248            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9249                formatter.write_str("struct meta.ListEventLogRequest")
9250            }
9251
9252            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogRequest, V::Error>
9253                where
9254                    V: serde::de::MapAccess<'de>,
9255            {
9256                while map_.next_key::<GeneratedField>()?.is_some() {
9257                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9258                }
9259                Ok(ListEventLogRequest {
9260                })
9261            }
9262        }
9263        deserializer.deserialize_struct("meta.ListEventLogRequest", FIELDS, GeneratedVisitor)
9264    }
9265}
9266impl serde::Serialize for ListEventLogResponse {
9267    #[allow(deprecated)]
9268    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9269    where
9270        S: serde::Serializer,
9271    {
9272        use serde::ser::SerializeStruct;
9273        let mut len = 0;
9274        if !self.event_logs.is_empty() {
9275            len += 1;
9276        }
9277        let mut struct_ser = serializer.serialize_struct("meta.ListEventLogResponse", len)?;
9278        if !self.event_logs.is_empty() {
9279            struct_ser.serialize_field("eventLogs", &self.event_logs)?;
9280        }
9281        struct_ser.end()
9282    }
9283}
9284impl<'de> serde::Deserialize<'de> for ListEventLogResponse {
9285    #[allow(deprecated)]
9286    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9287    where
9288        D: serde::Deserializer<'de>,
9289    {
9290        const FIELDS: &[&str] = &[
9291            "event_logs",
9292            "eventLogs",
9293        ];
9294
9295        #[allow(clippy::enum_variant_names)]
9296        enum GeneratedField {
9297            EventLogs,
9298        }
9299        impl<'de> serde::Deserialize<'de> for GeneratedField {
9300            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9301            where
9302                D: serde::Deserializer<'de>,
9303            {
9304                struct GeneratedVisitor;
9305
9306                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9307                    type Value = GeneratedField;
9308
9309                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9310                        write!(formatter, "expected one of: {:?}", &FIELDS)
9311                    }
9312
9313                    #[allow(unused_variables)]
9314                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9315                    where
9316                        E: serde::de::Error,
9317                    {
9318                        match value {
9319                            "eventLogs" | "event_logs" => Ok(GeneratedField::EventLogs),
9320                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9321                        }
9322                    }
9323                }
9324                deserializer.deserialize_identifier(GeneratedVisitor)
9325            }
9326        }
9327        struct GeneratedVisitor;
9328        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9329            type Value = ListEventLogResponse;
9330
9331            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9332                formatter.write_str("struct meta.ListEventLogResponse")
9333            }
9334
9335            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListEventLogResponse, V::Error>
9336                where
9337                    V: serde::de::MapAccess<'de>,
9338            {
9339                let mut event_logs__ = None;
9340                while let Some(k) = map_.next_key()? {
9341                    match k {
9342                        GeneratedField::EventLogs => {
9343                            if event_logs__.is_some() {
9344                                return Err(serde::de::Error::duplicate_field("eventLogs"));
9345                            }
9346                            event_logs__ = Some(map_.next_value()?);
9347                        }
9348                    }
9349                }
9350                Ok(ListEventLogResponse {
9351                    event_logs: event_logs__.unwrap_or_default(),
9352                })
9353            }
9354        }
9355        deserializer.deserialize_struct("meta.ListEventLogResponse", FIELDS, GeneratedVisitor)
9356    }
9357}
9358impl serde::Serialize for ListFragmentDistributionRequest {
9359    #[allow(deprecated)]
9360    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9361    where
9362        S: serde::Serializer,
9363    {
9364        use serde::ser::SerializeStruct;
9365        let len = 0;
9366        let struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionRequest", len)?;
9367        struct_ser.end()
9368    }
9369}
9370impl<'de> serde::Deserialize<'de> for ListFragmentDistributionRequest {
9371    #[allow(deprecated)]
9372    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9373    where
9374        D: serde::Deserializer<'de>,
9375    {
9376        const FIELDS: &[&str] = &[
9377        ];
9378
9379        #[allow(clippy::enum_variant_names)]
9380        enum GeneratedField {
9381        }
9382        impl<'de> serde::Deserialize<'de> for GeneratedField {
9383            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9384            where
9385                D: serde::Deserializer<'de>,
9386            {
9387                struct GeneratedVisitor;
9388
9389                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9390                    type Value = GeneratedField;
9391
9392                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9393                        write!(formatter, "expected one of: {:?}", &FIELDS)
9394                    }
9395
9396                    #[allow(unused_variables)]
9397                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9398                    where
9399                        E: serde::de::Error,
9400                    {
9401                            Err(serde::de::Error::unknown_field(value, FIELDS))
9402                    }
9403                }
9404                deserializer.deserialize_identifier(GeneratedVisitor)
9405            }
9406        }
9407        struct GeneratedVisitor;
9408        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9409            type Value = ListFragmentDistributionRequest;
9410
9411            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9412                formatter.write_str("struct meta.ListFragmentDistributionRequest")
9413            }
9414
9415            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionRequest, V::Error>
9416                where
9417                    V: serde::de::MapAccess<'de>,
9418            {
9419                while map_.next_key::<GeneratedField>()?.is_some() {
9420                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9421                }
9422                Ok(ListFragmentDistributionRequest {
9423                })
9424            }
9425        }
9426        deserializer.deserialize_struct("meta.ListFragmentDistributionRequest", FIELDS, GeneratedVisitor)
9427    }
9428}
9429impl serde::Serialize for ListFragmentDistributionResponse {
9430    #[allow(deprecated)]
9431    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9432    where
9433        S: serde::Serializer,
9434    {
9435        use serde::ser::SerializeStruct;
9436        let mut len = 0;
9437        if !self.distributions.is_empty() {
9438            len += 1;
9439        }
9440        let mut struct_ser = serializer.serialize_struct("meta.ListFragmentDistributionResponse", len)?;
9441        if !self.distributions.is_empty() {
9442            struct_ser.serialize_field("distributions", &self.distributions)?;
9443        }
9444        struct_ser.end()
9445    }
9446}
9447impl<'de> serde::Deserialize<'de> for ListFragmentDistributionResponse {
9448    #[allow(deprecated)]
9449    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9450    where
9451        D: serde::Deserializer<'de>,
9452    {
9453        const FIELDS: &[&str] = &[
9454            "distributions",
9455        ];
9456
9457        #[allow(clippy::enum_variant_names)]
9458        enum GeneratedField {
9459            Distributions,
9460        }
9461        impl<'de> serde::Deserialize<'de> for GeneratedField {
9462            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9463            where
9464                D: serde::Deserializer<'de>,
9465            {
9466                struct GeneratedVisitor;
9467
9468                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9469                    type Value = GeneratedField;
9470
9471                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9472                        write!(formatter, "expected one of: {:?}", &FIELDS)
9473                    }
9474
9475                    #[allow(unused_variables)]
9476                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9477                    where
9478                        E: serde::de::Error,
9479                    {
9480                        match value {
9481                            "distributions" => Ok(GeneratedField::Distributions),
9482                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9483                        }
9484                    }
9485                }
9486                deserializer.deserialize_identifier(GeneratedVisitor)
9487            }
9488        }
9489        struct GeneratedVisitor;
9490        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9491            type Value = ListFragmentDistributionResponse;
9492
9493            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9494                formatter.write_str("struct meta.ListFragmentDistributionResponse")
9495            }
9496
9497            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListFragmentDistributionResponse, V::Error>
9498                where
9499                    V: serde::de::MapAccess<'de>,
9500            {
9501                let mut distributions__ = None;
9502                while let Some(k) = map_.next_key()? {
9503                    match k {
9504                        GeneratedField::Distributions => {
9505                            if distributions__.is_some() {
9506                                return Err(serde::de::Error::duplicate_field("distributions"));
9507                            }
9508                            distributions__ = Some(map_.next_value()?);
9509                        }
9510                    }
9511                }
9512                Ok(ListFragmentDistributionResponse {
9513                    distributions: distributions__.unwrap_or_default(),
9514                })
9515            }
9516        }
9517        deserializer.deserialize_struct("meta.ListFragmentDistributionResponse", FIELDS, GeneratedVisitor)
9518    }
9519}
9520impl serde::Serialize for ListIcebergTablesRequest {
9521    #[allow(deprecated)]
9522    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9523    where
9524        S: serde::Serializer,
9525    {
9526        use serde::ser::SerializeStruct;
9527        let len = 0;
9528        let struct_ser = serializer.serialize_struct("meta.ListIcebergTablesRequest", len)?;
9529        struct_ser.end()
9530    }
9531}
9532impl<'de> serde::Deserialize<'de> for ListIcebergTablesRequest {
9533    #[allow(deprecated)]
9534    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9535    where
9536        D: serde::Deserializer<'de>,
9537    {
9538        const FIELDS: &[&str] = &[
9539        ];
9540
9541        #[allow(clippy::enum_variant_names)]
9542        enum GeneratedField {
9543        }
9544        impl<'de> serde::Deserialize<'de> for GeneratedField {
9545            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9546            where
9547                D: serde::Deserializer<'de>,
9548            {
9549                struct GeneratedVisitor;
9550
9551                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9552                    type Value = GeneratedField;
9553
9554                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9555                        write!(formatter, "expected one of: {:?}", &FIELDS)
9556                    }
9557
9558                    #[allow(unused_variables)]
9559                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9560                    where
9561                        E: serde::de::Error,
9562                    {
9563                            Err(serde::de::Error::unknown_field(value, FIELDS))
9564                    }
9565                }
9566                deserializer.deserialize_identifier(GeneratedVisitor)
9567            }
9568        }
9569        struct GeneratedVisitor;
9570        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9571            type Value = ListIcebergTablesRequest;
9572
9573            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9574                formatter.write_str("struct meta.ListIcebergTablesRequest")
9575            }
9576
9577            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesRequest, V::Error>
9578                where
9579                    V: serde::de::MapAccess<'de>,
9580            {
9581                while map_.next_key::<GeneratedField>()?.is_some() {
9582                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9583                }
9584                Ok(ListIcebergTablesRequest {
9585                })
9586            }
9587        }
9588        deserializer.deserialize_struct("meta.ListIcebergTablesRequest", FIELDS, GeneratedVisitor)
9589    }
9590}
9591impl serde::Serialize for ListIcebergTablesResponse {
9592    #[allow(deprecated)]
9593    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9594    where
9595        S: serde::Serializer,
9596    {
9597        use serde::ser::SerializeStruct;
9598        let mut len = 0;
9599        if !self.iceberg_tables.is_empty() {
9600            len += 1;
9601        }
9602        let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse", len)?;
9603        if !self.iceberg_tables.is_empty() {
9604            struct_ser.serialize_field("icebergTables", &self.iceberg_tables)?;
9605        }
9606        struct_ser.end()
9607    }
9608}
9609impl<'de> serde::Deserialize<'de> for ListIcebergTablesResponse {
9610    #[allow(deprecated)]
9611    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9612    where
9613        D: serde::Deserializer<'de>,
9614    {
9615        const FIELDS: &[&str] = &[
9616            "iceberg_tables",
9617            "icebergTables",
9618        ];
9619
9620        #[allow(clippy::enum_variant_names)]
9621        enum GeneratedField {
9622            IcebergTables,
9623        }
9624        impl<'de> serde::Deserialize<'de> for GeneratedField {
9625            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9626            where
9627                D: serde::Deserializer<'de>,
9628            {
9629                struct GeneratedVisitor;
9630
9631                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9632                    type Value = GeneratedField;
9633
9634                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9635                        write!(formatter, "expected one of: {:?}", &FIELDS)
9636                    }
9637
9638                    #[allow(unused_variables)]
9639                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9640                    where
9641                        E: serde::de::Error,
9642                    {
9643                        match value {
9644                            "icebergTables" | "iceberg_tables" => Ok(GeneratedField::IcebergTables),
9645                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9646                        }
9647                    }
9648                }
9649                deserializer.deserialize_identifier(GeneratedVisitor)
9650            }
9651        }
9652        struct GeneratedVisitor;
9653        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9654            type Value = ListIcebergTablesResponse;
9655
9656            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9657                formatter.write_str("struct meta.ListIcebergTablesResponse")
9658            }
9659
9660            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListIcebergTablesResponse, V::Error>
9661                where
9662                    V: serde::de::MapAccess<'de>,
9663            {
9664                let mut iceberg_tables__ = None;
9665                while let Some(k) = map_.next_key()? {
9666                    match k {
9667                        GeneratedField::IcebergTables => {
9668                            if iceberg_tables__.is_some() {
9669                                return Err(serde::de::Error::duplicate_field("icebergTables"));
9670                            }
9671                            iceberg_tables__ = Some(map_.next_value()?);
9672                        }
9673                    }
9674                }
9675                Ok(ListIcebergTablesResponse {
9676                    iceberg_tables: iceberg_tables__.unwrap_or_default(),
9677                })
9678            }
9679        }
9680        deserializer.deserialize_struct("meta.ListIcebergTablesResponse", FIELDS, GeneratedVisitor)
9681    }
9682}
9683impl serde::Serialize for list_iceberg_tables_response::IcebergTable {
9684    #[allow(deprecated)]
9685    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9686    where
9687        S: serde::Serializer,
9688    {
9689        use serde::ser::SerializeStruct;
9690        let mut len = 0;
9691        if !self.catalog_name.is_empty() {
9692            len += 1;
9693        }
9694        if !self.table_namespace.is_empty() {
9695            len += 1;
9696        }
9697        if !self.table_name.is_empty() {
9698            len += 1;
9699        }
9700        if self.metadata_location.is_some() {
9701            len += 1;
9702        }
9703        if self.previous_metadata_location.is_some() {
9704            len += 1;
9705        }
9706        if self.iceberg_type.is_some() {
9707            len += 1;
9708        }
9709        let mut struct_ser = serializer.serialize_struct("meta.ListIcebergTablesResponse.IcebergTable", len)?;
9710        if !self.catalog_name.is_empty() {
9711            struct_ser.serialize_field("catalogName", &self.catalog_name)?;
9712        }
9713        if !self.table_namespace.is_empty() {
9714            struct_ser.serialize_field("tableNamespace", &self.table_namespace)?;
9715        }
9716        if !self.table_name.is_empty() {
9717            struct_ser.serialize_field("tableName", &self.table_name)?;
9718        }
9719        if let Some(v) = self.metadata_location.as_ref() {
9720            struct_ser.serialize_field("metadataLocation", v)?;
9721        }
9722        if let Some(v) = self.previous_metadata_location.as_ref() {
9723            struct_ser.serialize_field("previousMetadataLocation", v)?;
9724        }
9725        if let Some(v) = self.iceberg_type.as_ref() {
9726            struct_ser.serialize_field("icebergType", v)?;
9727        }
9728        struct_ser.end()
9729    }
9730}
9731impl<'de> serde::Deserialize<'de> for list_iceberg_tables_response::IcebergTable {
9732    #[allow(deprecated)]
9733    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9734    where
9735        D: serde::Deserializer<'de>,
9736    {
9737        const FIELDS: &[&str] = &[
9738            "catalog_name",
9739            "catalogName",
9740            "table_namespace",
9741            "tableNamespace",
9742            "table_name",
9743            "tableName",
9744            "metadata_location",
9745            "metadataLocation",
9746            "previous_metadata_location",
9747            "previousMetadataLocation",
9748            "iceberg_type",
9749            "icebergType",
9750        ];
9751
9752        #[allow(clippy::enum_variant_names)]
9753        enum GeneratedField {
9754            CatalogName,
9755            TableNamespace,
9756            TableName,
9757            MetadataLocation,
9758            PreviousMetadataLocation,
9759            IcebergType,
9760        }
9761        impl<'de> serde::Deserialize<'de> for GeneratedField {
9762            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9763            where
9764                D: serde::Deserializer<'de>,
9765            {
9766                struct GeneratedVisitor;
9767
9768                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9769                    type Value = GeneratedField;
9770
9771                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9772                        write!(formatter, "expected one of: {:?}", &FIELDS)
9773                    }
9774
9775                    #[allow(unused_variables)]
9776                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9777                    where
9778                        E: serde::de::Error,
9779                    {
9780                        match value {
9781                            "catalogName" | "catalog_name" => Ok(GeneratedField::CatalogName),
9782                            "tableNamespace" | "table_namespace" => Ok(GeneratedField::TableNamespace),
9783                            "tableName" | "table_name" => Ok(GeneratedField::TableName),
9784                            "metadataLocation" | "metadata_location" => Ok(GeneratedField::MetadataLocation),
9785                            "previousMetadataLocation" | "previous_metadata_location" => Ok(GeneratedField::PreviousMetadataLocation),
9786                            "icebergType" | "iceberg_type" => Ok(GeneratedField::IcebergType),
9787                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9788                        }
9789                    }
9790                }
9791                deserializer.deserialize_identifier(GeneratedVisitor)
9792            }
9793        }
9794        struct GeneratedVisitor;
9795        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9796            type Value = list_iceberg_tables_response::IcebergTable;
9797
9798            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9799                formatter.write_str("struct meta.ListIcebergTablesResponse.IcebergTable")
9800            }
9801
9802            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_iceberg_tables_response::IcebergTable, V::Error>
9803                where
9804                    V: serde::de::MapAccess<'de>,
9805            {
9806                let mut catalog_name__ = None;
9807                let mut table_namespace__ = None;
9808                let mut table_name__ = None;
9809                let mut metadata_location__ = None;
9810                let mut previous_metadata_location__ = None;
9811                let mut iceberg_type__ = None;
9812                while let Some(k) = map_.next_key()? {
9813                    match k {
9814                        GeneratedField::CatalogName => {
9815                            if catalog_name__.is_some() {
9816                                return Err(serde::de::Error::duplicate_field("catalogName"));
9817                            }
9818                            catalog_name__ = Some(map_.next_value()?);
9819                        }
9820                        GeneratedField::TableNamespace => {
9821                            if table_namespace__.is_some() {
9822                                return Err(serde::de::Error::duplicate_field("tableNamespace"));
9823                            }
9824                            table_namespace__ = Some(map_.next_value()?);
9825                        }
9826                        GeneratedField::TableName => {
9827                            if table_name__.is_some() {
9828                                return Err(serde::de::Error::duplicate_field("tableName"));
9829                            }
9830                            table_name__ = Some(map_.next_value()?);
9831                        }
9832                        GeneratedField::MetadataLocation => {
9833                            if metadata_location__.is_some() {
9834                                return Err(serde::de::Error::duplicate_field("metadataLocation"));
9835                            }
9836                            metadata_location__ = map_.next_value()?;
9837                        }
9838                        GeneratedField::PreviousMetadataLocation => {
9839                            if previous_metadata_location__.is_some() {
9840                                return Err(serde::de::Error::duplicate_field("previousMetadataLocation"));
9841                            }
9842                            previous_metadata_location__ = map_.next_value()?;
9843                        }
9844                        GeneratedField::IcebergType => {
9845                            if iceberg_type__.is_some() {
9846                                return Err(serde::de::Error::duplicate_field("icebergType"));
9847                            }
9848                            iceberg_type__ = map_.next_value()?;
9849                        }
9850                    }
9851                }
9852                Ok(list_iceberg_tables_response::IcebergTable {
9853                    catalog_name: catalog_name__.unwrap_or_default(),
9854                    table_namespace: table_namespace__.unwrap_or_default(),
9855                    table_name: table_name__.unwrap_or_default(),
9856                    metadata_location: metadata_location__,
9857                    previous_metadata_location: previous_metadata_location__,
9858                    iceberg_type: iceberg_type__,
9859                })
9860            }
9861        }
9862        deserializer.deserialize_struct("meta.ListIcebergTablesResponse.IcebergTable", FIELDS, GeneratedVisitor)
9863    }
9864}
9865impl serde::Serialize for ListObjectDependenciesRequest {
9866    #[allow(deprecated)]
9867    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9868    where
9869        S: serde::Serializer,
9870    {
9871        use serde::ser::SerializeStruct;
9872        let len = 0;
9873        let struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesRequest", len)?;
9874        struct_ser.end()
9875    }
9876}
9877impl<'de> serde::Deserialize<'de> for ListObjectDependenciesRequest {
9878    #[allow(deprecated)]
9879    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9880    where
9881        D: serde::Deserializer<'de>,
9882    {
9883        const FIELDS: &[&str] = &[
9884        ];
9885
9886        #[allow(clippy::enum_variant_names)]
9887        enum GeneratedField {
9888        }
9889        impl<'de> serde::Deserialize<'de> for GeneratedField {
9890            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9891            where
9892                D: serde::Deserializer<'de>,
9893            {
9894                struct GeneratedVisitor;
9895
9896                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9897                    type Value = GeneratedField;
9898
9899                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9900                        write!(formatter, "expected one of: {:?}", &FIELDS)
9901                    }
9902
9903                    #[allow(unused_variables)]
9904                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9905                    where
9906                        E: serde::de::Error,
9907                    {
9908                            Err(serde::de::Error::unknown_field(value, FIELDS))
9909                    }
9910                }
9911                deserializer.deserialize_identifier(GeneratedVisitor)
9912            }
9913        }
9914        struct GeneratedVisitor;
9915        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9916            type Value = ListObjectDependenciesRequest;
9917
9918            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9919                formatter.write_str("struct meta.ListObjectDependenciesRequest")
9920            }
9921
9922            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesRequest, V::Error>
9923                where
9924                    V: serde::de::MapAccess<'de>,
9925            {
9926                while map_.next_key::<GeneratedField>()?.is_some() {
9927                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
9928                }
9929                Ok(ListObjectDependenciesRequest {
9930                })
9931            }
9932        }
9933        deserializer.deserialize_struct("meta.ListObjectDependenciesRequest", FIELDS, GeneratedVisitor)
9934    }
9935}
9936impl serde::Serialize for ListObjectDependenciesResponse {
9937    #[allow(deprecated)]
9938    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9939    where
9940        S: serde::Serializer,
9941    {
9942        use serde::ser::SerializeStruct;
9943        let mut len = 0;
9944        if !self.dependencies.is_empty() {
9945            len += 1;
9946        }
9947        let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse", len)?;
9948        if !self.dependencies.is_empty() {
9949            struct_ser.serialize_field("dependencies", &self.dependencies)?;
9950        }
9951        struct_ser.end()
9952    }
9953}
9954impl<'de> serde::Deserialize<'de> for ListObjectDependenciesResponse {
9955    #[allow(deprecated)]
9956    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9957    where
9958        D: serde::Deserializer<'de>,
9959    {
9960        const FIELDS: &[&str] = &[
9961            "dependencies",
9962        ];
9963
9964        #[allow(clippy::enum_variant_names)]
9965        enum GeneratedField {
9966            Dependencies,
9967        }
9968        impl<'de> serde::Deserialize<'de> for GeneratedField {
9969            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9970            where
9971                D: serde::Deserializer<'de>,
9972            {
9973                struct GeneratedVisitor;
9974
9975                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9976                    type Value = GeneratedField;
9977
9978                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9979                        write!(formatter, "expected one of: {:?}", &FIELDS)
9980                    }
9981
9982                    #[allow(unused_variables)]
9983                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9984                    where
9985                        E: serde::de::Error,
9986                    {
9987                        match value {
9988                            "dependencies" => Ok(GeneratedField::Dependencies),
9989                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9990                        }
9991                    }
9992                }
9993                deserializer.deserialize_identifier(GeneratedVisitor)
9994            }
9995        }
9996        struct GeneratedVisitor;
9997        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9998            type Value = ListObjectDependenciesResponse;
9999
10000            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10001                formatter.write_str("struct meta.ListObjectDependenciesResponse")
10002            }
10003
10004            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListObjectDependenciesResponse, V::Error>
10005                where
10006                    V: serde::de::MapAccess<'de>,
10007            {
10008                let mut dependencies__ = None;
10009                while let Some(k) = map_.next_key()? {
10010                    match k {
10011                        GeneratedField::Dependencies => {
10012                            if dependencies__.is_some() {
10013                                return Err(serde::de::Error::duplicate_field("dependencies"));
10014                            }
10015                            dependencies__ = Some(map_.next_value()?);
10016                        }
10017                    }
10018                }
10019                Ok(ListObjectDependenciesResponse {
10020                    dependencies: dependencies__.unwrap_or_default(),
10021                })
10022            }
10023        }
10024        deserializer.deserialize_struct("meta.ListObjectDependenciesResponse", FIELDS, GeneratedVisitor)
10025    }
10026}
10027impl serde::Serialize for list_object_dependencies_response::ObjectDependencies {
10028    #[allow(deprecated)]
10029    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10030    where
10031        S: serde::Serializer,
10032    {
10033        use serde::ser::SerializeStruct;
10034        let mut len = 0;
10035        if self.object_id != 0 {
10036            len += 1;
10037        }
10038        if self.referenced_object_id != 0 {
10039            len += 1;
10040        }
10041        let mut struct_ser = serializer.serialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", len)?;
10042        if self.object_id != 0 {
10043            struct_ser.serialize_field("objectId", &self.object_id)?;
10044        }
10045        if self.referenced_object_id != 0 {
10046            struct_ser.serialize_field("referencedObjectId", &self.referenced_object_id)?;
10047        }
10048        struct_ser.end()
10049    }
10050}
10051impl<'de> serde::Deserialize<'de> for list_object_dependencies_response::ObjectDependencies {
10052    #[allow(deprecated)]
10053    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10054    where
10055        D: serde::Deserializer<'de>,
10056    {
10057        const FIELDS: &[&str] = &[
10058            "object_id",
10059            "objectId",
10060            "referenced_object_id",
10061            "referencedObjectId",
10062        ];
10063
10064        #[allow(clippy::enum_variant_names)]
10065        enum GeneratedField {
10066            ObjectId,
10067            ReferencedObjectId,
10068        }
10069        impl<'de> serde::Deserialize<'de> for GeneratedField {
10070            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10071            where
10072                D: serde::Deserializer<'de>,
10073            {
10074                struct GeneratedVisitor;
10075
10076                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10077                    type Value = GeneratedField;
10078
10079                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10080                        write!(formatter, "expected one of: {:?}", &FIELDS)
10081                    }
10082
10083                    #[allow(unused_variables)]
10084                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10085                    where
10086                        E: serde::de::Error,
10087                    {
10088                        match value {
10089                            "objectId" | "object_id" => Ok(GeneratedField::ObjectId),
10090                            "referencedObjectId" | "referenced_object_id" => Ok(GeneratedField::ReferencedObjectId),
10091                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10092                        }
10093                    }
10094                }
10095                deserializer.deserialize_identifier(GeneratedVisitor)
10096            }
10097        }
10098        struct GeneratedVisitor;
10099        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10100            type Value = list_object_dependencies_response::ObjectDependencies;
10101
10102            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10103                formatter.write_str("struct meta.ListObjectDependenciesResponse.ObjectDependencies")
10104            }
10105
10106            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_object_dependencies_response::ObjectDependencies, V::Error>
10107                where
10108                    V: serde::de::MapAccess<'de>,
10109            {
10110                let mut object_id__ = None;
10111                let mut referenced_object_id__ = None;
10112                while let Some(k) = map_.next_key()? {
10113                    match k {
10114                        GeneratedField::ObjectId => {
10115                            if object_id__.is_some() {
10116                                return Err(serde::de::Error::duplicate_field("objectId"));
10117                            }
10118                            object_id__ = 
10119                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10120                            ;
10121                        }
10122                        GeneratedField::ReferencedObjectId => {
10123                            if referenced_object_id__.is_some() {
10124                                return Err(serde::de::Error::duplicate_field("referencedObjectId"));
10125                            }
10126                            referenced_object_id__ = 
10127                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10128                            ;
10129                        }
10130                    }
10131                }
10132                Ok(list_object_dependencies_response::ObjectDependencies {
10133                    object_id: object_id__.unwrap_or_default(),
10134                    referenced_object_id: referenced_object_id__.unwrap_or_default(),
10135                })
10136            }
10137        }
10138        deserializer.deserialize_struct("meta.ListObjectDependenciesResponse.ObjectDependencies", FIELDS, GeneratedVisitor)
10139    }
10140}
10141impl serde::Serialize for ListRateLimitsRequest {
10142    #[allow(deprecated)]
10143    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10144    where
10145        S: serde::Serializer,
10146    {
10147        use serde::ser::SerializeStruct;
10148        let len = 0;
10149        let struct_ser = serializer.serialize_struct("meta.ListRateLimitsRequest", len)?;
10150        struct_ser.end()
10151    }
10152}
10153impl<'de> serde::Deserialize<'de> for ListRateLimitsRequest {
10154    #[allow(deprecated)]
10155    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10156    where
10157        D: serde::Deserializer<'de>,
10158    {
10159        const FIELDS: &[&str] = &[
10160        ];
10161
10162        #[allow(clippy::enum_variant_names)]
10163        enum GeneratedField {
10164        }
10165        impl<'de> serde::Deserialize<'de> for GeneratedField {
10166            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10167            where
10168                D: serde::Deserializer<'de>,
10169            {
10170                struct GeneratedVisitor;
10171
10172                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10173                    type Value = GeneratedField;
10174
10175                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10176                        write!(formatter, "expected one of: {:?}", &FIELDS)
10177                    }
10178
10179                    #[allow(unused_variables)]
10180                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10181                    where
10182                        E: serde::de::Error,
10183                    {
10184                            Err(serde::de::Error::unknown_field(value, FIELDS))
10185                    }
10186                }
10187                deserializer.deserialize_identifier(GeneratedVisitor)
10188            }
10189        }
10190        struct GeneratedVisitor;
10191        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10192            type Value = ListRateLimitsRequest;
10193
10194            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10195                formatter.write_str("struct meta.ListRateLimitsRequest")
10196            }
10197
10198            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsRequest, V::Error>
10199                where
10200                    V: serde::de::MapAccess<'de>,
10201            {
10202                while map_.next_key::<GeneratedField>()?.is_some() {
10203                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10204                }
10205                Ok(ListRateLimitsRequest {
10206                })
10207            }
10208        }
10209        deserializer.deserialize_struct("meta.ListRateLimitsRequest", FIELDS, GeneratedVisitor)
10210    }
10211}
10212impl serde::Serialize for ListRateLimitsResponse {
10213    #[allow(deprecated)]
10214    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10215    where
10216        S: serde::Serializer,
10217    {
10218        use serde::ser::SerializeStruct;
10219        let mut len = 0;
10220        if !self.rate_limits.is_empty() {
10221            len += 1;
10222        }
10223        let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse", len)?;
10224        if !self.rate_limits.is_empty() {
10225            struct_ser.serialize_field("rateLimits", &self.rate_limits)?;
10226        }
10227        struct_ser.end()
10228    }
10229}
10230impl<'de> serde::Deserialize<'de> for ListRateLimitsResponse {
10231    #[allow(deprecated)]
10232    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10233    where
10234        D: serde::Deserializer<'de>,
10235    {
10236        const FIELDS: &[&str] = &[
10237            "rate_limits",
10238            "rateLimits",
10239        ];
10240
10241        #[allow(clippy::enum_variant_names)]
10242        enum GeneratedField {
10243            RateLimits,
10244        }
10245        impl<'de> serde::Deserialize<'de> for GeneratedField {
10246            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10247            where
10248                D: serde::Deserializer<'de>,
10249            {
10250                struct GeneratedVisitor;
10251
10252                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10253                    type Value = GeneratedField;
10254
10255                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10256                        write!(formatter, "expected one of: {:?}", &FIELDS)
10257                    }
10258
10259                    #[allow(unused_variables)]
10260                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10261                    where
10262                        E: serde::de::Error,
10263                    {
10264                        match value {
10265                            "rateLimits" | "rate_limits" => Ok(GeneratedField::RateLimits),
10266                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10267                        }
10268                    }
10269                }
10270                deserializer.deserialize_identifier(GeneratedVisitor)
10271            }
10272        }
10273        struct GeneratedVisitor;
10274        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10275            type Value = ListRateLimitsResponse;
10276
10277            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10278                formatter.write_str("struct meta.ListRateLimitsResponse")
10279            }
10280
10281            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListRateLimitsResponse, V::Error>
10282                where
10283                    V: serde::de::MapAccess<'de>,
10284            {
10285                let mut rate_limits__ = None;
10286                while let Some(k) = map_.next_key()? {
10287                    match k {
10288                        GeneratedField::RateLimits => {
10289                            if rate_limits__.is_some() {
10290                                return Err(serde::de::Error::duplicate_field("rateLimits"));
10291                            }
10292                            rate_limits__ = Some(map_.next_value()?);
10293                        }
10294                    }
10295                }
10296                Ok(ListRateLimitsResponse {
10297                    rate_limits: rate_limits__.unwrap_or_default(),
10298                })
10299            }
10300        }
10301        deserializer.deserialize_struct("meta.ListRateLimitsResponse", FIELDS, GeneratedVisitor)
10302    }
10303}
10304impl serde::Serialize for list_rate_limits_response::RateLimitInfo {
10305    #[allow(deprecated)]
10306    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10307    where
10308        S: serde::Serializer,
10309    {
10310        use serde::ser::SerializeStruct;
10311        let mut len = 0;
10312        if self.fragment_id != 0 {
10313            len += 1;
10314        }
10315        if self.job_id != 0 {
10316            len += 1;
10317        }
10318        if self.fragment_type_mask != 0 {
10319            len += 1;
10320        }
10321        if self.rate_limit != 0 {
10322            len += 1;
10323        }
10324        if !self.node_name.is_empty() {
10325            len += 1;
10326        }
10327        let mut struct_ser = serializer.serialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", len)?;
10328        if self.fragment_id != 0 {
10329            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10330        }
10331        if self.job_id != 0 {
10332            struct_ser.serialize_field("jobId", &self.job_id)?;
10333        }
10334        if self.fragment_type_mask != 0 {
10335            struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
10336        }
10337        if self.rate_limit != 0 {
10338            struct_ser.serialize_field("rateLimit", &self.rate_limit)?;
10339        }
10340        if !self.node_name.is_empty() {
10341            struct_ser.serialize_field("nodeName", &self.node_name)?;
10342        }
10343        struct_ser.end()
10344    }
10345}
10346impl<'de> serde::Deserialize<'de> for list_rate_limits_response::RateLimitInfo {
10347    #[allow(deprecated)]
10348    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10349    where
10350        D: serde::Deserializer<'de>,
10351    {
10352        const FIELDS: &[&str] = &[
10353            "fragment_id",
10354            "fragmentId",
10355            "job_id",
10356            "jobId",
10357            "fragment_type_mask",
10358            "fragmentTypeMask",
10359            "rate_limit",
10360            "rateLimit",
10361            "node_name",
10362            "nodeName",
10363        ];
10364
10365        #[allow(clippy::enum_variant_names)]
10366        enum GeneratedField {
10367            FragmentId,
10368            JobId,
10369            FragmentTypeMask,
10370            RateLimit,
10371            NodeName,
10372        }
10373        impl<'de> serde::Deserialize<'de> for GeneratedField {
10374            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10375            where
10376                D: serde::Deserializer<'de>,
10377            {
10378                struct GeneratedVisitor;
10379
10380                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10381                    type Value = GeneratedField;
10382
10383                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10384                        write!(formatter, "expected one of: {:?}", &FIELDS)
10385                    }
10386
10387                    #[allow(unused_variables)]
10388                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10389                    where
10390                        E: serde::de::Error,
10391                    {
10392                        match value {
10393                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10394                            "jobId" | "job_id" => Ok(GeneratedField::JobId),
10395                            "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
10396                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10397                            "nodeName" | "node_name" => Ok(GeneratedField::NodeName),
10398                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10399                        }
10400                    }
10401                }
10402                deserializer.deserialize_identifier(GeneratedVisitor)
10403            }
10404        }
10405        struct GeneratedVisitor;
10406        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10407            type Value = list_rate_limits_response::RateLimitInfo;
10408
10409            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10410                formatter.write_str("struct meta.ListRateLimitsResponse.RateLimitInfo")
10411            }
10412
10413            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_rate_limits_response::RateLimitInfo, V::Error>
10414                where
10415                    V: serde::de::MapAccess<'de>,
10416            {
10417                let mut fragment_id__ = None;
10418                let mut job_id__ = None;
10419                let mut fragment_type_mask__ = None;
10420                let mut rate_limit__ = None;
10421                let mut node_name__ = None;
10422                while let Some(k) = map_.next_key()? {
10423                    match k {
10424                        GeneratedField::FragmentId => {
10425                            if fragment_id__.is_some() {
10426                                return Err(serde::de::Error::duplicate_field("fragmentId"));
10427                            }
10428                            fragment_id__ = 
10429                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10430                            ;
10431                        }
10432                        GeneratedField::JobId => {
10433                            if job_id__.is_some() {
10434                                return Err(serde::de::Error::duplicate_field("jobId"));
10435                            }
10436                            job_id__ = 
10437                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10438                            ;
10439                        }
10440                        GeneratedField::FragmentTypeMask => {
10441                            if fragment_type_mask__.is_some() {
10442                                return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
10443                            }
10444                            fragment_type_mask__ = 
10445                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10446                            ;
10447                        }
10448                        GeneratedField::RateLimit => {
10449                            if rate_limit__.is_some() {
10450                                return Err(serde::de::Error::duplicate_field("rateLimit"));
10451                            }
10452                            rate_limit__ = 
10453                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10454                            ;
10455                        }
10456                        GeneratedField::NodeName => {
10457                            if node_name__.is_some() {
10458                                return Err(serde::de::Error::duplicate_field("nodeName"));
10459                            }
10460                            node_name__ = Some(map_.next_value()?);
10461                        }
10462                    }
10463                }
10464                Ok(list_rate_limits_response::RateLimitInfo {
10465                    fragment_id: fragment_id__.unwrap_or_default(),
10466                    job_id: job_id__.unwrap_or_default(),
10467                    fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
10468                    rate_limit: rate_limit__.unwrap_or_default(),
10469                    node_name: node_name__.unwrap_or_default(),
10470                })
10471            }
10472        }
10473        deserializer.deserialize_struct("meta.ListRateLimitsResponse.RateLimitInfo", FIELDS, GeneratedVisitor)
10474    }
10475}
10476impl serde::Serialize for ListStreamingJobStatesRequest {
10477    #[allow(deprecated)]
10478    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10479    where
10480        S: serde::Serializer,
10481    {
10482        use serde::ser::SerializeStruct;
10483        let len = 0;
10484        let struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesRequest", len)?;
10485        struct_ser.end()
10486    }
10487}
10488impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesRequest {
10489    #[allow(deprecated)]
10490    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10491    where
10492        D: serde::Deserializer<'de>,
10493    {
10494        const FIELDS: &[&str] = &[
10495        ];
10496
10497        #[allow(clippy::enum_variant_names)]
10498        enum GeneratedField {
10499        }
10500        impl<'de> serde::Deserialize<'de> for GeneratedField {
10501            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10502            where
10503                D: serde::Deserializer<'de>,
10504            {
10505                struct GeneratedVisitor;
10506
10507                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10508                    type Value = GeneratedField;
10509
10510                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10511                        write!(formatter, "expected one of: {:?}", &FIELDS)
10512                    }
10513
10514                    #[allow(unused_variables)]
10515                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10516                    where
10517                        E: serde::de::Error,
10518                    {
10519                            Err(serde::de::Error::unknown_field(value, FIELDS))
10520                    }
10521                }
10522                deserializer.deserialize_identifier(GeneratedVisitor)
10523            }
10524        }
10525        struct GeneratedVisitor;
10526        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10527            type Value = ListStreamingJobStatesRequest;
10528
10529            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10530                formatter.write_str("struct meta.ListStreamingJobStatesRequest")
10531            }
10532
10533            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesRequest, V::Error>
10534                where
10535                    V: serde::de::MapAccess<'de>,
10536            {
10537                while map_.next_key::<GeneratedField>()?.is_some() {
10538                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
10539                }
10540                Ok(ListStreamingJobStatesRequest {
10541                })
10542            }
10543        }
10544        deserializer.deserialize_struct("meta.ListStreamingJobStatesRequest", FIELDS, GeneratedVisitor)
10545    }
10546}
10547impl serde::Serialize for ListStreamingJobStatesResponse {
10548    #[allow(deprecated)]
10549    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10550    where
10551        S: serde::Serializer,
10552    {
10553        use serde::ser::SerializeStruct;
10554        let mut len = 0;
10555        if !self.states.is_empty() {
10556            len += 1;
10557        }
10558        let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse", len)?;
10559        if !self.states.is_empty() {
10560            struct_ser.serialize_field("states", &self.states)?;
10561        }
10562        struct_ser.end()
10563    }
10564}
10565impl<'de> serde::Deserialize<'de> for ListStreamingJobStatesResponse {
10566    #[allow(deprecated)]
10567    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10568    where
10569        D: serde::Deserializer<'de>,
10570    {
10571        const FIELDS: &[&str] = &[
10572            "states",
10573        ];
10574
10575        #[allow(clippy::enum_variant_names)]
10576        enum GeneratedField {
10577            States,
10578        }
10579        impl<'de> serde::Deserialize<'de> for GeneratedField {
10580            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10581            where
10582                D: serde::Deserializer<'de>,
10583            {
10584                struct GeneratedVisitor;
10585
10586                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10587                    type Value = GeneratedField;
10588
10589                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10590                        write!(formatter, "expected one of: {:?}", &FIELDS)
10591                    }
10592
10593                    #[allow(unused_variables)]
10594                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10595                    where
10596                        E: serde::de::Error,
10597                    {
10598                        match value {
10599                            "states" => Ok(GeneratedField::States),
10600                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10601                        }
10602                    }
10603                }
10604                deserializer.deserialize_identifier(GeneratedVisitor)
10605            }
10606        }
10607        struct GeneratedVisitor;
10608        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10609            type Value = ListStreamingJobStatesResponse;
10610
10611            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10612                formatter.write_str("struct meta.ListStreamingJobStatesResponse")
10613            }
10614
10615            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListStreamingJobStatesResponse, V::Error>
10616                where
10617                    V: serde::de::MapAccess<'de>,
10618            {
10619                let mut states__ = None;
10620                while let Some(k) = map_.next_key()? {
10621                    match k {
10622                        GeneratedField::States => {
10623                            if states__.is_some() {
10624                                return Err(serde::de::Error::duplicate_field("states"));
10625                            }
10626                            states__ = Some(map_.next_value()?);
10627                        }
10628                    }
10629                }
10630                Ok(ListStreamingJobStatesResponse {
10631                    states: states__.unwrap_or_default(),
10632                })
10633            }
10634        }
10635        deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse", FIELDS, GeneratedVisitor)
10636    }
10637}
10638impl serde::Serialize for list_streaming_job_states_response::StreamingJobState {
10639    #[allow(deprecated)]
10640    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10641    where
10642        S: serde::Serializer,
10643    {
10644        use serde::ser::SerializeStruct;
10645        let mut len = 0;
10646        if self.table_id != 0 {
10647            len += 1;
10648        }
10649        if self.state != 0 {
10650            len += 1;
10651        }
10652        if self.parallelism.is_some() {
10653            len += 1;
10654        }
10655        if self.max_parallelism != 0 {
10656            len += 1;
10657        }
10658        if !self.name.is_empty() {
10659            len += 1;
10660        }
10661        if !self.resource_group.is_empty() {
10662            len += 1;
10663        }
10664        if self.database_id != 0 {
10665            len += 1;
10666        }
10667        if self.schema_id != 0 {
10668            len += 1;
10669        }
10670        let mut struct_ser = serializer.serialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", len)?;
10671        if self.table_id != 0 {
10672            struct_ser.serialize_field("tableId", &self.table_id)?;
10673        }
10674        if self.state != 0 {
10675            let v = table_fragments::State::try_from(self.state)
10676                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
10677            struct_ser.serialize_field("state", &v)?;
10678        }
10679        if let Some(v) = self.parallelism.as_ref() {
10680            struct_ser.serialize_field("parallelism", v)?;
10681        }
10682        if self.max_parallelism != 0 {
10683            struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10684        }
10685        if !self.name.is_empty() {
10686            struct_ser.serialize_field("name", &self.name)?;
10687        }
10688        if !self.resource_group.is_empty() {
10689            struct_ser.serialize_field("resourceGroup", &self.resource_group)?;
10690        }
10691        if self.database_id != 0 {
10692            struct_ser.serialize_field("databaseId", &self.database_id)?;
10693        }
10694        if self.schema_id != 0 {
10695            struct_ser.serialize_field("schemaId", &self.schema_id)?;
10696        }
10697        struct_ser.end()
10698    }
10699}
10700impl<'de> serde::Deserialize<'de> for list_streaming_job_states_response::StreamingJobState {
10701    #[allow(deprecated)]
10702    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10703    where
10704        D: serde::Deserializer<'de>,
10705    {
10706        const FIELDS: &[&str] = &[
10707            "table_id",
10708            "tableId",
10709            "state",
10710            "parallelism",
10711            "max_parallelism",
10712            "maxParallelism",
10713            "name",
10714            "resource_group",
10715            "resourceGroup",
10716            "database_id",
10717            "databaseId",
10718            "schema_id",
10719            "schemaId",
10720        ];
10721
10722        #[allow(clippy::enum_variant_names)]
10723        enum GeneratedField {
10724            TableId,
10725            State,
10726            Parallelism,
10727            MaxParallelism,
10728            Name,
10729            ResourceGroup,
10730            DatabaseId,
10731            SchemaId,
10732        }
10733        impl<'de> serde::Deserialize<'de> for GeneratedField {
10734            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10735            where
10736                D: serde::Deserializer<'de>,
10737            {
10738                struct GeneratedVisitor;
10739
10740                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10741                    type Value = GeneratedField;
10742
10743                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10744                        write!(formatter, "expected one of: {:?}", &FIELDS)
10745                    }
10746
10747                    #[allow(unused_variables)]
10748                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10749                    where
10750                        E: serde::de::Error,
10751                    {
10752                        match value {
10753                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
10754                            "state" => Ok(GeneratedField::State),
10755                            "parallelism" => Ok(GeneratedField::Parallelism),
10756                            "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
10757                            "name" => Ok(GeneratedField::Name),
10758                            "resourceGroup" | "resource_group" => Ok(GeneratedField::ResourceGroup),
10759                            "databaseId" | "database_id" => Ok(GeneratedField::DatabaseId),
10760                            "schemaId" | "schema_id" => Ok(GeneratedField::SchemaId),
10761                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10762                        }
10763                    }
10764                }
10765                deserializer.deserialize_identifier(GeneratedVisitor)
10766            }
10767        }
10768        struct GeneratedVisitor;
10769        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10770            type Value = list_streaming_job_states_response::StreamingJobState;
10771
10772            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10773                formatter.write_str("struct meta.ListStreamingJobStatesResponse.StreamingJobState")
10774            }
10775
10776            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_streaming_job_states_response::StreamingJobState, V::Error>
10777                where
10778                    V: serde::de::MapAccess<'de>,
10779            {
10780                let mut table_id__ = None;
10781                let mut state__ = None;
10782                let mut parallelism__ = None;
10783                let mut max_parallelism__ = None;
10784                let mut name__ = None;
10785                let mut resource_group__ = None;
10786                let mut database_id__ = None;
10787                let mut schema_id__ = None;
10788                while let Some(k) = map_.next_key()? {
10789                    match k {
10790                        GeneratedField::TableId => {
10791                            if table_id__.is_some() {
10792                                return Err(serde::de::Error::duplicate_field("tableId"));
10793                            }
10794                            table_id__ = 
10795                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10796                            ;
10797                        }
10798                        GeneratedField::State => {
10799                            if state__.is_some() {
10800                                return Err(serde::de::Error::duplicate_field("state"));
10801                            }
10802                            state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
10803                        }
10804                        GeneratedField::Parallelism => {
10805                            if parallelism__.is_some() {
10806                                return Err(serde::de::Error::duplicate_field("parallelism"));
10807                            }
10808                            parallelism__ = map_.next_value()?;
10809                        }
10810                        GeneratedField::MaxParallelism => {
10811                            if max_parallelism__.is_some() {
10812                                return Err(serde::de::Error::duplicate_field("maxParallelism"));
10813                            }
10814                            max_parallelism__ = 
10815                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10816                            ;
10817                        }
10818                        GeneratedField::Name => {
10819                            if name__.is_some() {
10820                                return Err(serde::de::Error::duplicate_field("name"));
10821                            }
10822                            name__ = Some(map_.next_value()?);
10823                        }
10824                        GeneratedField::ResourceGroup => {
10825                            if resource_group__.is_some() {
10826                                return Err(serde::de::Error::duplicate_field("resourceGroup"));
10827                            }
10828                            resource_group__ = Some(map_.next_value()?);
10829                        }
10830                        GeneratedField::DatabaseId => {
10831                            if database_id__.is_some() {
10832                                return Err(serde::de::Error::duplicate_field("databaseId"));
10833                            }
10834                            database_id__ = 
10835                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10836                            ;
10837                        }
10838                        GeneratedField::SchemaId => {
10839                            if schema_id__.is_some() {
10840                                return Err(serde::de::Error::duplicate_field("schemaId"));
10841                            }
10842                            schema_id__ = 
10843                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10844                            ;
10845                        }
10846                    }
10847                }
10848                Ok(list_streaming_job_states_response::StreamingJobState {
10849                    table_id: table_id__.unwrap_or_default(),
10850                    state: state__.unwrap_or_default(),
10851                    parallelism: parallelism__,
10852                    max_parallelism: max_parallelism__.unwrap_or_default(),
10853                    name: name__.unwrap_or_default(),
10854                    resource_group: resource_group__.unwrap_or_default(),
10855                    database_id: database_id__.unwrap_or_default(),
10856                    schema_id: schema_id__.unwrap_or_default(),
10857                })
10858            }
10859        }
10860        deserializer.deserialize_struct("meta.ListStreamingJobStatesResponse.StreamingJobState", FIELDS, GeneratedVisitor)
10861    }
10862}
10863impl serde::Serialize for ListTableFragmentsRequest {
10864    #[allow(deprecated)]
10865    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10866    where
10867        S: serde::Serializer,
10868    {
10869        use serde::ser::SerializeStruct;
10870        let mut len = 0;
10871        if !self.table_ids.is_empty() {
10872            len += 1;
10873        }
10874        let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsRequest", len)?;
10875        if !self.table_ids.is_empty() {
10876            struct_ser.serialize_field("tableIds", &self.table_ids)?;
10877        }
10878        struct_ser.end()
10879    }
10880}
10881impl<'de> serde::Deserialize<'de> for ListTableFragmentsRequest {
10882    #[allow(deprecated)]
10883    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10884    where
10885        D: serde::Deserializer<'de>,
10886    {
10887        const FIELDS: &[&str] = &[
10888            "table_ids",
10889            "tableIds",
10890        ];
10891
10892        #[allow(clippy::enum_variant_names)]
10893        enum GeneratedField {
10894            TableIds,
10895        }
10896        impl<'de> serde::Deserialize<'de> for GeneratedField {
10897            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10898            where
10899                D: serde::Deserializer<'de>,
10900            {
10901                struct GeneratedVisitor;
10902
10903                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10904                    type Value = GeneratedField;
10905
10906                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10907                        write!(formatter, "expected one of: {:?}", &FIELDS)
10908                    }
10909
10910                    #[allow(unused_variables)]
10911                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10912                    where
10913                        E: serde::de::Error,
10914                    {
10915                        match value {
10916                            "tableIds" | "table_ids" => Ok(GeneratedField::TableIds),
10917                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10918                        }
10919                    }
10920                }
10921                deserializer.deserialize_identifier(GeneratedVisitor)
10922            }
10923        }
10924        struct GeneratedVisitor;
10925        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10926            type Value = ListTableFragmentsRequest;
10927
10928            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10929                formatter.write_str("struct meta.ListTableFragmentsRequest")
10930            }
10931
10932            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsRequest, V::Error>
10933                where
10934                    V: serde::de::MapAccess<'de>,
10935            {
10936                let mut table_ids__ = None;
10937                while let Some(k) = map_.next_key()? {
10938                    match k {
10939                        GeneratedField::TableIds => {
10940                            if table_ids__.is_some() {
10941                                return Err(serde::de::Error::duplicate_field("tableIds"));
10942                            }
10943                            table_ids__ = 
10944                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10945                                    .into_iter().map(|x| x.0).collect())
10946                            ;
10947                        }
10948                    }
10949                }
10950                Ok(ListTableFragmentsRequest {
10951                    table_ids: table_ids__.unwrap_or_default(),
10952                })
10953            }
10954        }
10955        deserializer.deserialize_struct("meta.ListTableFragmentsRequest", FIELDS, GeneratedVisitor)
10956    }
10957}
10958impl serde::Serialize for ListTableFragmentsResponse {
10959    #[allow(deprecated)]
10960    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10961    where
10962        S: serde::Serializer,
10963    {
10964        use serde::ser::SerializeStruct;
10965        let mut len = 0;
10966        if !self.table_fragments.is_empty() {
10967            len += 1;
10968        }
10969        let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse", len)?;
10970        if !self.table_fragments.is_empty() {
10971            struct_ser.serialize_field("tableFragments", &self.table_fragments)?;
10972        }
10973        struct_ser.end()
10974    }
10975}
10976impl<'de> serde::Deserialize<'de> for ListTableFragmentsResponse {
10977    #[allow(deprecated)]
10978    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10979    where
10980        D: serde::Deserializer<'de>,
10981    {
10982        const FIELDS: &[&str] = &[
10983            "table_fragments",
10984            "tableFragments",
10985        ];
10986
10987        #[allow(clippy::enum_variant_names)]
10988        enum GeneratedField {
10989            TableFragments,
10990        }
10991        impl<'de> serde::Deserialize<'de> for GeneratedField {
10992            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10993            where
10994                D: serde::Deserializer<'de>,
10995            {
10996                struct GeneratedVisitor;
10997
10998                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10999                    type Value = GeneratedField;
11000
11001                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11002                        write!(formatter, "expected one of: {:?}", &FIELDS)
11003                    }
11004
11005                    #[allow(unused_variables)]
11006                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11007                    where
11008                        E: serde::de::Error,
11009                    {
11010                        match value {
11011                            "tableFragments" | "table_fragments" => Ok(GeneratedField::TableFragments),
11012                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11013                        }
11014                    }
11015                }
11016                deserializer.deserialize_identifier(GeneratedVisitor)
11017            }
11018        }
11019        struct GeneratedVisitor;
11020        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11021            type Value = ListTableFragmentsResponse;
11022
11023            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11024                formatter.write_str("struct meta.ListTableFragmentsResponse")
11025            }
11026
11027            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ListTableFragmentsResponse, V::Error>
11028                where
11029                    V: serde::de::MapAccess<'de>,
11030            {
11031                let mut table_fragments__ = None;
11032                while let Some(k) = map_.next_key()? {
11033                    match k {
11034                        GeneratedField::TableFragments => {
11035                            if table_fragments__.is_some() {
11036                                return Err(serde::de::Error::duplicate_field("tableFragments"));
11037                            }
11038                            table_fragments__ = Some(
11039                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11040                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
11041                            );
11042                        }
11043                    }
11044                }
11045                Ok(ListTableFragmentsResponse {
11046                    table_fragments: table_fragments__.unwrap_or_default(),
11047                })
11048            }
11049        }
11050        deserializer.deserialize_struct("meta.ListTableFragmentsResponse", FIELDS, GeneratedVisitor)
11051    }
11052}
11053impl serde::Serialize for list_table_fragments_response::ActorInfo {
11054    #[allow(deprecated)]
11055    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11056    where
11057        S: serde::Serializer,
11058    {
11059        use serde::ser::SerializeStruct;
11060        let mut len = 0;
11061        if self.id != 0 {
11062            len += 1;
11063        }
11064        if self.node.is_some() {
11065            len += 1;
11066        }
11067        if !self.dispatcher.is_empty() {
11068            len += 1;
11069        }
11070        let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.ActorInfo", len)?;
11071        if self.id != 0 {
11072            struct_ser.serialize_field("id", &self.id)?;
11073        }
11074        if let Some(v) = self.node.as_ref() {
11075            struct_ser.serialize_field("node", v)?;
11076        }
11077        if !self.dispatcher.is_empty() {
11078            struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
11079        }
11080        struct_ser.end()
11081    }
11082}
11083impl<'de> serde::Deserialize<'de> for list_table_fragments_response::ActorInfo {
11084    #[allow(deprecated)]
11085    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11086    where
11087        D: serde::Deserializer<'de>,
11088    {
11089        const FIELDS: &[&str] = &[
11090            "id",
11091            "node",
11092            "dispatcher",
11093        ];
11094
11095        #[allow(clippy::enum_variant_names)]
11096        enum GeneratedField {
11097            Id,
11098            Node,
11099            Dispatcher,
11100        }
11101        impl<'de> serde::Deserialize<'de> for GeneratedField {
11102            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11103            where
11104                D: serde::Deserializer<'de>,
11105            {
11106                struct GeneratedVisitor;
11107
11108                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11109                    type Value = GeneratedField;
11110
11111                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11112                        write!(formatter, "expected one of: {:?}", &FIELDS)
11113                    }
11114
11115                    #[allow(unused_variables)]
11116                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11117                    where
11118                        E: serde::de::Error,
11119                    {
11120                        match value {
11121                            "id" => Ok(GeneratedField::Id),
11122                            "node" => Ok(GeneratedField::Node),
11123                            "dispatcher" => Ok(GeneratedField::Dispatcher),
11124                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11125                        }
11126                    }
11127                }
11128                deserializer.deserialize_identifier(GeneratedVisitor)
11129            }
11130        }
11131        struct GeneratedVisitor;
11132        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11133            type Value = list_table_fragments_response::ActorInfo;
11134
11135            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11136                formatter.write_str("struct meta.ListTableFragmentsResponse.ActorInfo")
11137            }
11138
11139            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::ActorInfo, V::Error>
11140                where
11141                    V: serde::de::MapAccess<'de>,
11142            {
11143                let mut id__ = None;
11144                let mut node__ = None;
11145                let mut dispatcher__ = None;
11146                while let Some(k) = map_.next_key()? {
11147                    match k {
11148                        GeneratedField::Id => {
11149                            if id__.is_some() {
11150                                return Err(serde::de::Error::duplicate_field("id"));
11151                            }
11152                            id__ = 
11153                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11154                            ;
11155                        }
11156                        GeneratedField::Node => {
11157                            if node__.is_some() {
11158                                return Err(serde::de::Error::duplicate_field("node"));
11159                            }
11160                            node__ = map_.next_value()?;
11161                        }
11162                        GeneratedField::Dispatcher => {
11163                            if dispatcher__.is_some() {
11164                                return Err(serde::de::Error::duplicate_field("dispatcher"));
11165                            }
11166                            dispatcher__ = Some(map_.next_value()?);
11167                        }
11168                    }
11169                }
11170                Ok(list_table_fragments_response::ActorInfo {
11171                    id: id__.unwrap_or_default(),
11172                    node: node__,
11173                    dispatcher: dispatcher__.unwrap_or_default(),
11174                })
11175            }
11176        }
11177        deserializer.deserialize_struct("meta.ListTableFragmentsResponse.ActorInfo", FIELDS, GeneratedVisitor)
11178    }
11179}
11180impl serde::Serialize for list_table_fragments_response::FragmentInfo {
11181    #[allow(deprecated)]
11182    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11183    where
11184        S: serde::Serializer,
11185    {
11186        use serde::ser::SerializeStruct;
11187        let mut len = 0;
11188        if self.id != 0 {
11189            len += 1;
11190        }
11191        if !self.actors.is_empty() {
11192            len += 1;
11193        }
11194        let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", len)?;
11195        if self.id != 0 {
11196            struct_ser.serialize_field("id", &self.id)?;
11197        }
11198        if !self.actors.is_empty() {
11199            struct_ser.serialize_field("actors", &self.actors)?;
11200        }
11201        struct_ser.end()
11202    }
11203}
11204impl<'de> serde::Deserialize<'de> for list_table_fragments_response::FragmentInfo {
11205    #[allow(deprecated)]
11206    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11207    where
11208        D: serde::Deserializer<'de>,
11209    {
11210        const FIELDS: &[&str] = &[
11211            "id",
11212            "actors",
11213        ];
11214
11215        #[allow(clippy::enum_variant_names)]
11216        enum GeneratedField {
11217            Id,
11218            Actors,
11219        }
11220        impl<'de> serde::Deserialize<'de> for GeneratedField {
11221            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11222            where
11223                D: serde::Deserializer<'de>,
11224            {
11225                struct GeneratedVisitor;
11226
11227                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11228                    type Value = GeneratedField;
11229
11230                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11231                        write!(formatter, "expected one of: {:?}", &FIELDS)
11232                    }
11233
11234                    #[allow(unused_variables)]
11235                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11236                    where
11237                        E: serde::de::Error,
11238                    {
11239                        match value {
11240                            "id" => Ok(GeneratedField::Id),
11241                            "actors" => Ok(GeneratedField::Actors),
11242                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11243                        }
11244                    }
11245                }
11246                deserializer.deserialize_identifier(GeneratedVisitor)
11247            }
11248        }
11249        struct GeneratedVisitor;
11250        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11251            type Value = list_table_fragments_response::FragmentInfo;
11252
11253            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11254                formatter.write_str("struct meta.ListTableFragmentsResponse.FragmentInfo")
11255            }
11256
11257            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::FragmentInfo, V::Error>
11258                where
11259                    V: serde::de::MapAccess<'de>,
11260            {
11261                let mut id__ = None;
11262                let mut actors__ = None;
11263                while let Some(k) = map_.next_key()? {
11264                    match k {
11265                        GeneratedField::Id => {
11266                            if id__.is_some() {
11267                                return Err(serde::de::Error::duplicate_field("id"));
11268                            }
11269                            id__ = 
11270                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11271                            ;
11272                        }
11273                        GeneratedField::Actors => {
11274                            if actors__.is_some() {
11275                                return Err(serde::de::Error::duplicate_field("actors"));
11276                            }
11277                            actors__ = Some(map_.next_value()?);
11278                        }
11279                    }
11280                }
11281                Ok(list_table_fragments_response::FragmentInfo {
11282                    id: id__.unwrap_or_default(),
11283                    actors: actors__.unwrap_or_default(),
11284                })
11285            }
11286        }
11287        deserializer.deserialize_struct("meta.ListTableFragmentsResponse.FragmentInfo", FIELDS, GeneratedVisitor)
11288    }
11289}
11290impl serde::Serialize for list_table_fragments_response::TableFragmentInfo {
11291    #[allow(deprecated)]
11292    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11293    where
11294        S: serde::Serializer,
11295    {
11296        use serde::ser::SerializeStruct;
11297        let mut len = 0;
11298        if !self.fragments.is_empty() {
11299            len += 1;
11300        }
11301        if self.ctx.is_some() {
11302            len += 1;
11303        }
11304        let mut struct_ser = serializer.serialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", len)?;
11305        if !self.fragments.is_empty() {
11306            struct_ser.serialize_field("fragments", &self.fragments)?;
11307        }
11308        if let Some(v) = self.ctx.as_ref() {
11309            struct_ser.serialize_field("ctx", v)?;
11310        }
11311        struct_ser.end()
11312    }
11313}
11314impl<'de> serde::Deserialize<'de> for list_table_fragments_response::TableFragmentInfo {
11315    #[allow(deprecated)]
11316    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11317    where
11318        D: serde::Deserializer<'de>,
11319    {
11320        const FIELDS: &[&str] = &[
11321            "fragments",
11322            "ctx",
11323        ];
11324
11325        #[allow(clippy::enum_variant_names)]
11326        enum GeneratedField {
11327            Fragments,
11328            Ctx,
11329        }
11330        impl<'de> serde::Deserialize<'de> for GeneratedField {
11331            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11332            where
11333                D: serde::Deserializer<'de>,
11334            {
11335                struct GeneratedVisitor;
11336
11337                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11338                    type Value = GeneratedField;
11339
11340                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11341                        write!(formatter, "expected one of: {:?}", &FIELDS)
11342                    }
11343
11344                    #[allow(unused_variables)]
11345                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11346                    where
11347                        E: serde::de::Error,
11348                    {
11349                        match value {
11350                            "fragments" => Ok(GeneratedField::Fragments),
11351                            "ctx" => Ok(GeneratedField::Ctx),
11352                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11353                        }
11354                    }
11355                }
11356                deserializer.deserialize_identifier(GeneratedVisitor)
11357            }
11358        }
11359        struct GeneratedVisitor;
11360        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11361            type Value = list_table_fragments_response::TableFragmentInfo;
11362
11363            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11364                formatter.write_str("struct meta.ListTableFragmentsResponse.TableFragmentInfo")
11365            }
11366
11367            fn visit_map<V>(self, mut map_: V) -> std::result::Result<list_table_fragments_response::TableFragmentInfo, V::Error>
11368                where
11369                    V: serde::de::MapAccess<'de>,
11370            {
11371                let mut fragments__ = None;
11372                let mut ctx__ = None;
11373                while let Some(k) = map_.next_key()? {
11374                    match k {
11375                        GeneratedField::Fragments => {
11376                            if fragments__.is_some() {
11377                                return Err(serde::de::Error::duplicate_field("fragments"));
11378                            }
11379                            fragments__ = Some(map_.next_value()?);
11380                        }
11381                        GeneratedField::Ctx => {
11382                            if ctx__.is_some() {
11383                                return Err(serde::de::Error::duplicate_field("ctx"));
11384                            }
11385                            ctx__ = map_.next_value()?;
11386                        }
11387                    }
11388                }
11389                Ok(list_table_fragments_response::TableFragmentInfo {
11390                    fragments: fragments__.unwrap_or_default(),
11391                    ctx: ctx__,
11392                })
11393            }
11394        }
11395        deserializer.deserialize_struct("meta.ListTableFragmentsResponse.TableFragmentInfo", FIELDS, GeneratedVisitor)
11396    }
11397}
11398impl serde::Serialize for MembersRequest {
11399    #[allow(deprecated)]
11400    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11401    where
11402        S: serde::Serializer,
11403    {
11404        use serde::ser::SerializeStruct;
11405        let len = 0;
11406        let struct_ser = serializer.serialize_struct("meta.MembersRequest", len)?;
11407        struct_ser.end()
11408    }
11409}
11410impl<'de> serde::Deserialize<'de> for MembersRequest {
11411    #[allow(deprecated)]
11412    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11413    where
11414        D: serde::Deserializer<'de>,
11415    {
11416        const FIELDS: &[&str] = &[
11417        ];
11418
11419        #[allow(clippy::enum_variant_names)]
11420        enum GeneratedField {
11421        }
11422        impl<'de> serde::Deserialize<'de> for GeneratedField {
11423            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11424            where
11425                D: serde::Deserializer<'de>,
11426            {
11427                struct GeneratedVisitor;
11428
11429                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11430                    type Value = GeneratedField;
11431
11432                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11433                        write!(formatter, "expected one of: {:?}", &FIELDS)
11434                    }
11435
11436                    #[allow(unused_variables)]
11437                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11438                    where
11439                        E: serde::de::Error,
11440                    {
11441                            Err(serde::de::Error::unknown_field(value, FIELDS))
11442                    }
11443                }
11444                deserializer.deserialize_identifier(GeneratedVisitor)
11445            }
11446        }
11447        struct GeneratedVisitor;
11448        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11449            type Value = MembersRequest;
11450
11451            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11452                formatter.write_str("struct meta.MembersRequest")
11453            }
11454
11455            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersRequest, V::Error>
11456                where
11457                    V: serde::de::MapAccess<'de>,
11458            {
11459                while map_.next_key::<GeneratedField>()?.is_some() {
11460                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
11461                }
11462                Ok(MembersRequest {
11463                })
11464            }
11465        }
11466        deserializer.deserialize_struct("meta.MembersRequest", FIELDS, GeneratedVisitor)
11467    }
11468}
11469impl serde::Serialize for MembersResponse {
11470    #[allow(deprecated)]
11471    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11472    where
11473        S: serde::Serializer,
11474    {
11475        use serde::ser::SerializeStruct;
11476        let mut len = 0;
11477        if !self.members.is_empty() {
11478            len += 1;
11479        }
11480        let mut struct_ser = serializer.serialize_struct("meta.MembersResponse", len)?;
11481        if !self.members.is_empty() {
11482            struct_ser.serialize_field("members", &self.members)?;
11483        }
11484        struct_ser.end()
11485    }
11486}
11487impl<'de> serde::Deserialize<'de> for MembersResponse {
11488    #[allow(deprecated)]
11489    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11490    where
11491        D: serde::Deserializer<'de>,
11492    {
11493        const FIELDS: &[&str] = &[
11494            "members",
11495        ];
11496
11497        #[allow(clippy::enum_variant_names)]
11498        enum GeneratedField {
11499            Members,
11500        }
11501        impl<'de> serde::Deserialize<'de> for GeneratedField {
11502            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11503            where
11504                D: serde::Deserializer<'de>,
11505            {
11506                struct GeneratedVisitor;
11507
11508                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11509                    type Value = GeneratedField;
11510
11511                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11512                        write!(formatter, "expected one of: {:?}", &FIELDS)
11513                    }
11514
11515                    #[allow(unused_variables)]
11516                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11517                    where
11518                        E: serde::de::Error,
11519                    {
11520                        match value {
11521                            "members" => Ok(GeneratedField::Members),
11522                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11523                        }
11524                    }
11525                }
11526                deserializer.deserialize_identifier(GeneratedVisitor)
11527            }
11528        }
11529        struct GeneratedVisitor;
11530        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11531            type Value = MembersResponse;
11532
11533            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11534                formatter.write_str("struct meta.MembersResponse")
11535            }
11536
11537            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MembersResponse, V::Error>
11538                where
11539                    V: serde::de::MapAccess<'de>,
11540            {
11541                let mut members__ = None;
11542                while let Some(k) = map_.next_key()? {
11543                    match k {
11544                        GeneratedField::Members => {
11545                            if members__.is_some() {
11546                                return Err(serde::de::Error::duplicate_field("members"));
11547                            }
11548                            members__ = Some(map_.next_value()?);
11549                        }
11550                    }
11551                }
11552                Ok(MembersResponse {
11553                    members: members__.unwrap_or_default(),
11554                })
11555            }
11556        }
11557        deserializer.deserialize_struct("meta.MembersResponse", FIELDS, GeneratedVisitor)
11558    }
11559}
11560impl serde::Serialize for MetaMember {
11561    #[allow(deprecated)]
11562    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11563    where
11564        S: serde::Serializer,
11565    {
11566        use serde::ser::SerializeStruct;
11567        let mut len = 0;
11568        if self.address.is_some() {
11569            len += 1;
11570        }
11571        if self.is_leader {
11572            len += 1;
11573        }
11574        let mut struct_ser = serializer.serialize_struct("meta.MetaMember", len)?;
11575        if let Some(v) = self.address.as_ref() {
11576            struct_ser.serialize_field("address", v)?;
11577        }
11578        if self.is_leader {
11579            struct_ser.serialize_field("isLeader", &self.is_leader)?;
11580        }
11581        struct_ser.end()
11582    }
11583}
11584impl<'de> serde::Deserialize<'de> for MetaMember {
11585    #[allow(deprecated)]
11586    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11587    where
11588        D: serde::Deserializer<'de>,
11589    {
11590        const FIELDS: &[&str] = &[
11591            "address",
11592            "is_leader",
11593            "isLeader",
11594        ];
11595
11596        #[allow(clippy::enum_variant_names)]
11597        enum GeneratedField {
11598            Address,
11599            IsLeader,
11600        }
11601        impl<'de> serde::Deserialize<'de> for GeneratedField {
11602            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11603            where
11604                D: serde::Deserializer<'de>,
11605            {
11606                struct GeneratedVisitor;
11607
11608                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11609                    type Value = GeneratedField;
11610
11611                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11612                        write!(formatter, "expected one of: {:?}", &FIELDS)
11613                    }
11614
11615                    #[allow(unused_variables)]
11616                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11617                    where
11618                        E: serde::de::Error,
11619                    {
11620                        match value {
11621                            "address" => Ok(GeneratedField::Address),
11622                            "isLeader" | "is_leader" => Ok(GeneratedField::IsLeader),
11623                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11624                        }
11625                    }
11626                }
11627                deserializer.deserialize_identifier(GeneratedVisitor)
11628            }
11629        }
11630        struct GeneratedVisitor;
11631        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11632            type Value = MetaMember;
11633
11634            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11635                formatter.write_str("struct meta.MetaMember")
11636            }
11637
11638            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaMember, V::Error>
11639                where
11640                    V: serde::de::MapAccess<'de>,
11641            {
11642                let mut address__ = None;
11643                let mut is_leader__ = None;
11644                while let Some(k) = map_.next_key()? {
11645                    match k {
11646                        GeneratedField::Address => {
11647                            if address__.is_some() {
11648                                return Err(serde::de::Error::duplicate_field("address"));
11649                            }
11650                            address__ = map_.next_value()?;
11651                        }
11652                        GeneratedField::IsLeader => {
11653                            if is_leader__.is_some() {
11654                                return Err(serde::de::Error::duplicate_field("isLeader"));
11655                            }
11656                            is_leader__ = Some(map_.next_value()?);
11657                        }
11658                    }
11659                }
11660                Ok(MetaMember {
11661                    address: address__,
11662                    is_leader: is_leader__.unwrap_or_default(),
11663                })
11664            }
11665        }
11666        deserializer.deserialize_struct("meta.MetaMember", FIELDS, GeneratedVisitor)
11667    }
11668}
11669impl serde::Serialize for MetaSnapshot {
11670    #[allow(deprecated)]
11671    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11672    where
11673        S: serde::Serializer,
11674    {
11675        use serde::ser::SerializeStruct;
11676        let mut len = 0;
11677        if !self.databases.is_empty() {
11678            len += 1;
11679        }
11680        if !self.schemas.is_empty() {
11681            len += 1;
11682        }
11683        if !self.sources.is_empty() {
11684            len += 1;
11685        }
11686        if !self.sinks.is_empty() {
11687            len += 1;
11688        }
11689        if !self.tables.is_empty() {
11690            len += 1;
11691        }
11692        if !self.indexes.is_empty() {
11693            len += 1;
11694        }
11695        if !self.views.is_empty() {
11696            len += 1;
11697        }
11698        if !self.functions.is_empty() {
11699            len += 1;
11700        }
11701        if !self.connections.is_empty() {
11702            len += 1;
11703        }
11704        if !self.subscriptions.is_empty() {
11705            len += 1;
11706        }
11707        if !self.users.is_empty() {
11708            len += 1;
11709        }
11710        if self.session_params.is_some() {
11711            len += 1;
11712        }
11713        if !self.secrets.is_empty() {
11714            len += 1;
11715        }
11716        if self.compute_node_total_cpu_count != 0 {
11717            len += 1;
11718        }
11719        if !self.nodes.is_empty() {
11720            len += 1;
11721        }
11722        if self.hummock_version.is_some() {
11723            len += 1;
11724        }
11725        if self.meta_backup_manifest_id.is_some() {
11726            len += 1;
11727        }
11728        if self.hummock_write_limits.is_some() {
11729            len += 1;
11730        }
11731        if !self.streaming_worker_slot_mappings.is_empty() {
11732            len += 1;
11733        }
11734        if !self.serving_worker_slot_mappings.is_empty() {
11735            len += 1;
11736        }
11737        if self.version.is_some() {
11738            len += 1;
11739        }
11740        let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot", len)?;
11741        if !self.databases.is_empty() {
11742            struct_ser.serialize_field("databases", &self.databases)?;
11743        }
11744        if !self.schemas.is_empty() {
11745            struct_ser.serialize_field("schemas", &self.schemas)?;
11746        }
11747        if !self.sources.is_empty() {
11748            struct_ser.serialize_field("sources", &self.sources)?;
11749        }
11750        if !self.sinks.is_empty() {
11751            struct_ser.serialize_field("sinks", &self.sinks)?;
11752        }
11753        if !self.tables.is_empty() {
11754            struct_ser.serialize_field("tables", &self.tables)?;
11755        }
11756        if !self.indexes.is_empty() {
11757            struct_ser.serialize_field("indexes", &self.indexes)?;
11758        }
11759        if !self.views.is_empty() {
11760            struct_ser.serialize_field("views", &self.views)?;
11761        }
11762        if !self.functions.is_empty() {
11763            struct_ser.serialize_field("functions", &self.functions)?;
11764        }
11765        if !self.connections.is_empty() {
11766            struct_ser.serialize_field("connections", &self.connections)?;
11767        }
11768        if !self.subscriptions.is_empty() {
11769            struct_ser.serialize_field("subscriptions", &self.subscriptions)?;
11770        }
11771        if !self.users.is_empty() {
11772            struct_ser.serialize_field("users", &self.users)?;
11773        }
11774        if let Some(v) = self.session_params.as_ref() {
11775            struct_ser.serialize_field("sessionParams", v)?;
11776        }
11777        if !self.secrets.is_empty() {
11778            struct_ser.serialize_field("secrets", &self.secrets)?;
11779        }
11780        if self.compute_node_total_cpu_count != 0 {
11781            #[allow(clippy::needless_borrow)]
11782            #[allow(clippy::needless_borrows_for_generic_args)]
11783            struct_ser.serialize_field("computeNodeTotalCpuCount", ToString::to_string(&self.compute_node_total_cpu_count).as_str())?;
11784        }
11785        if !self.nodes.is_empty() {
11786            struct_ser.serialize_field("nodes", &self.nodes)?;
11787        }
11788        if let Some(v) = self.hummock_version.as_ref() {
11789            struct_ser.serialize_field("hummockVersion", v)?;
11790        }
11791        if let Some(v) = self.meta_backup_manifest_id.as_ref() {
11792            struct_ser.serialize_field("metaBackupManifestId", v)?;
11793        }
11794        if let Some(v) = self.hummock_write_limits.as_ref() {
11795            struct_ser.serialize_field("hummockWriteLimits", v)?;
11796        }
11797        if !self.streaming_worker_slot_mappings.is_empty() {
11798            struct_ser.serialize_field("streamingWorkerSlotMappings", &self.streaming_worker_slot_mappings)?;
11799        }
11800        if !self.serving_worker_slot_mappings.is_empty() {
11801            struct_ser.serialize_field("servingWorkerSlotMappings", &self.serving_worker_slot_mappings)?;
11802        }
11803        if let Some(v) = self.version.as_ref() {
11804            struct_ser.serialize_field("version", v)?;
11805        }
11806        struct_ser.end()
11807    }
11808}
11809impl<'de> serde::Deserialize<'de> for MetaSnapshot {
11810    #[allow(deprecated)]
11811    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11812    where
11813        D: serde::Deserializer<'de>,
11814    {
11815        const FIELDS: &[&str] = &[
11816            "databases",
11817            "schemas",
11818            "sources",
11819            "sinks",
11820            "tables",
11821            "indexes",
11822            "views",
11823            "functions",
11824            "connections",
11825            "subscriptions",
11826            "users",
11827            "session_params",
11828            "sessionParams",
11829            "secrets",
11830            "compute_node_total_cpu_count",
11831            "computeNodeTotalCpuCount",
11832            "nodes",
11833            "hummock_version",
11834            "hummockVersion",
11835            "meta_backup_manifest_id",
11836            "metaBackupManifestId",
11837            "hummock_write_limits",
11838            "hummockWriteLimits",
11839            "streaming_worker_slot_mappings",
11840            "streamingWorkerSlotMappings",
11841            "serving_worker_slot_mappings",
11842            "servingWorkerSlotMappings",
11843            "version",
11844        ];
11845
11846        #[allow(clippy::enum_variant_names)]
11847        enum GeneratedField {
11848            Databases,
11849            Schemas,
11850            Sources,
11851            Sinks,
11852            Tables,
11853            Indexes,
11854            Views,
11855            Functions,
11856            Connections,
11857            Subscriptions,
11858            Users,
11859            SessionParams,
11860            Secrets,
11861            ComputeNodeTotalCpuCount,
11862            Nodes,
11863            HummockVersion,
11864            MetaBackupManifestId,
11865            HummockWriteLimits,
11866            StreamingWorkerSlotMappings,
11867            ServingWorkerSlotMappings,
11868            Version,
11869        }
11870        impl<'de> serde::Deserialize<'de> for GeneratedField {
11871            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11872            where
11873                D: serde::Deserializer<'de>,
11874            {
11875                struct GeneratedVisitor;
11876
11877                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11878                    type Value = GeneratedField;
11879
11880                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11881                        write!(formatter, "expected one of: {:?}", &FIELDS)
11882                    }
11883
11884                    #[allow(unused_variables)]
11885                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11886                    where
11887                        E: serde::de::Error,
11888                    {
11889                        match value {
11890                            "databases" => Ok(GeneratedField::Databases),
11891                            "schemas" => Ok(GeneratedField::Schemas),
11892                            "sources" => Ok(GeneratedField::Sources),
11893                            "sinks" => Ok(GeneratedField::Sinks),
11894                            "tables" => Ok(GeneratedField::Tables),
11895                            "indexes" => Ok(GeneratedField::Indexes),
11896                            "views" => Ok(GeneratedField::Views),
11897                            "functions" => Ok(GeneratedField::Functions),
11898                            "connections" => Ok(GeneratedField::Connections),
11899                            "subscriptions" => Ok(GeneratedField::Subscriptions),
11900                            "users" => Ok(GeneratedField::Users),
11901                            "sessionParams" | "session_params" => Ok(GeneratedField::SessionParams),
11902                            "secrets" => Ok(GeneratedField::Secrets),
11903                            "computeNodeTotalCpuCount" | "compute_node_total_cpu_count" => Ok(GeneratedField::ComputeNodeTotalCpuCount),
11904                            "nodes" => Ok(GeneratedField::Nodes),
11905                            "hummockVersion" | "hummock_version" => Ok(GeneratedField::HummockVersion),
11906                            "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
11907                            "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
11908                            "streamingWorkerSlotMappings" | "streaming_worker_slot_mappings" => Ok(GeneratedField::StreamingWorkerSlotMappings),
11909                            "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
11910                            "version" => Ok(GeneratedField::Version),
11911                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11912                        }
11913                    }
11914                }
11915                deserializer.deserialize_identifier(GeneratedVisitor)
11916            }
11917        }
11918        struct GeneratedVisitor;
11919        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11920            type Value = MetaSnapshot;
11921
11922            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11923                formatter.write_str("struct meta.MetaSnapshot")
11924            }
11925
11926            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MetaSnapshot, V::Error>
11927                where
11928                    V: serde::de::MapAccess<'de>,
11929            {
11930                let mut databases__ = None;
11931                let mut schemas__ = None;
11932                let mut sources__ = None;
11933                let mut sinks__ = None;
11934                let mut tables__ = None;
11935                let mut indexes__ = None;
11936                let mut views__ = None;
11937                let mut functions__ = None;
11938                let mut connections__ = None;
11939                let mut subscriptions__ = None;
11940                let mut users__ = None;
11941                let mut session_params__ = None;
11942                let mut secrets__ = None;
11943                let mut compute_node_total_cpu_count__ = None;
11944                let mut nodes__ = None;
11945                let mut hummock_version__ = None;
11946                let mut meta_backup_manifest_id__ = None;
11947                let mut hummock_write_limits__ = None;
11948                let mut streaming_worker_slot_mappings__ = None;
11949                let mut serving_worker_slot_mappings__ = None;
11950                let mut version__ = None;
11951                while let Some(k) = map_.next_key()? {
11952                    match k {
11953                        GeneratedField::Databases => {
11954                            if databases__.is_some() {
11955                                return Err(serde::de::Error::duplicate_field("databases"));
11956                            }
11957                            databases__ = Some(map_.next_value()?);
11958                        }
11959                        GeneratedField::Schemas => {
11960                            if schemas__.is_some() {
11961                                return Err(serde::de::Error::duplicate_field("schemas"));
11962                            }
11963                            schemas__ = Some(map_.next_value()?);
11964                        }
11965                        GeneratedField::Sources => {
11966                            if sources__.is_some() {
11967                                return Err(serde::de::Error::duplicate_field("sources"));
11968                            }
11969                            sources__ = Some(map_.next_value()?);
11970                        }
11971                        GeneratedField::Sinks => {
11972                            if sinks__.is_some() {
11973                                return Err(serde::de::Error::duplicate_field("sinks"));
11974                            }
11975                            sinks__ = Some(map_.next_value()?);
11976                        }
11977                        GeneratedField::Tables => {
11978                            if tables__.is_some() {
11979                                return Err(serde::de::Error::duplicate_field("tables"));
11980                            }
11981                            tables__ = Some(map_.next_value()?);
11982                        }
11983                        GeneratedField::Indexes => {
11984                            if indexes__.is_some() {
11985                                return Err(serde::de::Error::duplicate_field("indexes"));
11986                            }
11987                            indexes__ = Some(map_.next_value()?);
11988                        }
11989                        GeneratedField::Views => {
11990                            if views__.is_some() {
11991                                return Err(serde::de::Error::duplicate_field("views"));
11992                            }
11993                            views__ = Some(map_.next_value()?);
11994                        }
11995                        GeneratedField::Functions => {
11996                            if functions__.is_some() {
11997                                return Err(serde::de::Error::duplicate_field("functions"));
11998                            }
11999                            functions__ = Some(map_.next_value()?);
12000                        }
12001                        GeneratedField::Connections => {
12002                            if connections__.is_some() {
12003                                return Err(serde::de::Error::duplicate_field("connections"));
12004                            }
12005                            connections__ = Some(map_.next_value()?);
12006                        }
12007                        GeneratedField::Subscriptions => {
12008                            if subscriptions__.is_some() {
12009                                return Err(serde::de::Error::duplicate_field("subscriptions"));
12010                            }
12011                            subscriptions__ = Some(map_.next_value()?);
12012                        }
12013                        GeneratedField::Users => {
12014                            if users__.is_some() {
12015                                return Err(serde::de::Error::duplicate_field("users"));
12016                            }
12017                            users__ = Some(map_.next_value()?);
12018                        }
12019                        GeneratedField::SessionParams => {
12020                            if session_params__.is_some() {
12021                                return Err(serde::de::Error::duplicate_field("sessionParams"));
12022                            }
12023                            session_params__ = map_.next_value()?;
12024                        }
12025                        GeneratedField::Secrets => {
12026                            if secrets__.is_some() {
12027                                return Err(serde::de::Error::duplicate_field("secrets"));
12028                            }
12029                            secrets__ = Some(map_.next_value()?);
12030                        }
12031                        GeneratedField::ComputeNodeTotalCpuCount => {
12032                            if compute_node_total_cpu_count__.is_some() {
12033                                return Err(serde::de::Error::duplicate_field("computeNodeTotalCpuCount"));
12034                            }
12035                            compute_node_total_cpu_count__ = 
12036                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12037                            ;
12038                        }
12039                        GeneratedField::Nodes => {
12040                            if nodes__.is_some() {
12041                                return Err(serde::de::Error::duplicate_field("nodes"));
12042                            }
12043                            nodes__ = Some(map_.next_value()?);
12044                        }
12045                        GeneratedField::HummockVersion => {
12046                            if hummock_version__.is_some() {
12047                                return Err(serde::de::Error::duplicate_field("hummockVersion"));
12048                            }
12049                            hummock_version__ = map_.next_value()?;
12050                        }
12051                        GeneratedField::MetaBackupManifestId => {
12052                            if meta_backup_manifest_id__.is_some() {
12053                                return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
12054                            }
12055                            meta_backup_manifest_id__ = map_.next_value()?;
12056                        }
12057                        GeneratedField::HummockWriteLimits => {
12058                            if hummock_write_limits__.is_some() {
12059                                return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
12060                            }
12061                            hummock_write_limits__ = map_.next_value()?;
12062                        }
12063                        GeneratedField::StreamingWorkerSlotMappings => {
12064                            if streaming_worker_slot_mappings__.is_some() {
12065                                return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappings"));
12066                            }
12067                            streaming_worker_slot_mappings__ = Some(map_.next_value()?);
12068                        }
12069                        GeneratedField::ServingWorkerSlotMappings => {
12070                            if serving_worker_slot_mappings__.is_some() {
12071                                return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
12072                            }
12073                            serving_worker_slot_mappings__ = Some(map_.next_value()?);
12074                        }
12075                        GeneratedField::Version => {
12076                            if version__.is_some() {
12077                                return Err(serde::de::Error::duplicate_field("version"));
12078                            }
12079                            version__ = map_.next_value()?;
12080                        }
12081                    }
12082                }
12083                Ok(MetaSnapshot {
12084                    databases: databases__.unwrap_or_default(),
12085                    schemas: schemas__.unwrap_or_default(),
12086                    sources: sources__.unwrap_or_default(),
12087                    sinks: sinks__.unwrap_or_default(),
12088                    tables: tables__.unwrap_or_default(),
12089                    indexes: indexes__.unwrap_or_default(),
12090                    views: views__.unwrap_or_default(),
12091                    functions: functions__.unwrap_or_default(),
12092                    connections: connections__.unwrap_or_default(),
12093                    subscriptions: subscriptions__.unwrap_or_default(),
12094                    users: users__.unwrap_or_default(),
12095                    session_params: session_params__,
12096                    secrets: secrets__.unwrap_or_default(),
12097                    compute_node_total_cpu_count: compute_node_total_cpu_count__.unwrap_or_default(),
12098                    nodes: nodes__.unwrap_or_default(),
12099                    hummock_version: hummock_version__,
12100                    meta_backup_manifest_id: meta_backup_manifest_id__,
12101                    hummock_write_limits: hummock_write_limits__,
12102                    streaming_worker_slot_mappings: streaming_worker_slot_mappings__.unwrap_or_default(),
12103                    serving_worker_slot_mappings: serving_worker_slot_mappings__.unwrap_or_default(),
12104                    version: version__,
12105                })
12106            }
12107        }
12108        deserializer.deserialize_struct("meta.MetaSnapshot", FIELDS, GeneratedVisitor)
12109    }
12110}
12111impl serde::Serialize for meta_snapshot::SnapshotVersion {
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.catalog_version != 0 {
12120            len += 1;
12121        }
12122        if self.worker_node_version != 0 {
12123            len += 1;
12124        }
12125        if self.streaming_worker_slot_mapping_version != 0 {
12126            len += 1;
12127        }
12128        let mut struct_ser = serializer.serialize_struct("meta.MetaSnapshot.SnapshotVersion", len)?;
12129        if self.catalog_version != 0 {
12130            #[allow(clippy::needless_borrow)]
12131            #[allow(clippy::needless_borrows_for_generic_args)]
12132            struct_ser.serialize_field("catalogVersion", ToString::to_string(&self.catalog_version).as_str())?;
12133        }
12134        if self.worker_node_version != 0 {
12135            #[allow(clippy::needless_borrow)]
12136            #[allow(clippy::needless_borrows_for_generic_args)]
12137            struct_ser.serialize_field("workerNodeVersion", ToString::to_string(&self.worker_node_version).as_str())?;
12138        }
12139        if self.streaming_worker_slot_mapping_version != 0 {
12140            #[allow(clippy::needless_borrow)]
12141            #[allow(clippy::needless_borrows_for_generic_args)]
12142            struct_ser.serialize_field("streamingWorkerSlotMappingVersion", ToString::to_string(&self.streaming_worker_slot_mapping_version).as_str())?;
12143        }
12144        struct_ser.end()
12145    }
12146}
12147impl<'de> serde::Deserialize<'de> for meta_snapshot::SnapshotVersion {
12148    #[allow(deprecated)]
12149    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12150    where
12151        D: serde::Deserializer<'de>,
12152    {
12153        const FIELDS: &[&str] = &[
12154            "catalog_version",
12155            "catalogVersion",
12156            "worker_node_version",
12157            "workerNodeVersion",
12158            "streaming_worker_slot_mapping_version",
12159            "streamingWorkerSlotMappingVersion",
12160        ];
12161
12162        #[allow(clippy::enum_variant_names)]
12163        enum GeneratedField {
12164            CatalogVersion,
12165            WorkerNodeVersion,
12166            StreamingWorkerSlotMappingVersion,
12167        }
12168        impl<'de> serde::Deserialize<'de> for GeneratedField {
12169            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12170            where
12171                D: serde::Deserializer<'de>,
12172            {
12173                struct GeneratedVisitor;
12174
12175                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12176                    type Value = GeneratedField;
12177
12178                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12179                        write!(formatter, "expected one of: {:?}", &FIELDS)
12180                    }
12181
12182                    #[allow(unused_variables)]
12183                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12184                    where
12185                        E: serde::de::Error,
12186                    {
12187                        match value {
12188                            "catalogVersion" | "catalog_version" => Ok(GeneratedField::CatalogVersion),
12189                            "workerNodeVersion" | "worker_node_version" => Ok(GeneratedField::WorkerNodeVersion),
12190                            "streamingWorkerSlotMappingVersion" | "streaming_worker_slot_mapping_version" => Ok(GeneratedField::StreamingWorkerSlotMappingVersion),
12191                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12192                        }
12193                    }
12194                }
12195                deserializer.deserialize_identifier(GeneratedVisitor)
12196            }
12197        }
12198        struct GeneratedVisitor;
12199        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12200            type Value = meta_snapshot::SnapshotVersion;
12201
12202            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12203                formatter.write_str("struct meta.MetaSnapshot.SnapshotVersion")
12204            }
12205
12206            fn visit_map<V>(self, mut map_: V) -> std::result::Result<meta_snapshot::SnapshotVersion, V::Error>
12207                where
12208                    V: serde::de::MapAccess<'de>,
12209            {
12210                let mut catalog_version__ = None;
12211                let mut worker_node_version__ = None;
12212                let mut streaming_worker_slot_mapping_version__ = None;
12213                while let Some(k) = map_.next_key()? {
12214                    match k {
12215                        GeneratedField::CatalogVersion => {
12216                            if catalog_version__.is_some() {
12217                                return Err(serde::de::Error::duplicate_field("catalogVersion"));
12218                            }
12219                            catalog_version__ = 
12220                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12221                            ;
12222                        }
12223                        GeneratedField::WorkerNodeVersion => {
12224                            if worker_node_version__.is_some() {
12225                                return Err(serde::de::Error::duplicate_field("workerNodeVersion"));
12226                            }
12227                            worker_node_version__ = 
12228                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12229                            ;
12230                        }
12231                        GeneratedField::StreamingWorkerSlotMappingVersion => {
12232                            if streaming_worker_slot_mapping_version__.is_some() {
12233                                return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMappingVersion"));
12234                            }
12235                            streaming_worker_slot_mapping_version__ = 
12236                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12237                            ;
12238                        }
12239                    }
12240                }
12241                Ok(meta_snapshot::SnapshotVersion {
12242                    catalog_version: catalog_version__.unwrap_or_default(),
12243                    worker_node_version: worker_node_version__.unwrap_or_default(),
12244                    streaming_worker_slot_mapping_version: streaming_worker_slot_mapping_version__.unwrap_or_default(),
12245                })
12246            }
12247        }
12248        deserializer.deserialize_struct("meta.MetaSnapshot.SnapshotVersion", FIELDS, GeneratedVisitor)
12249    }
12250}
12251impl serde::Serialize for MigrationPlan {
12252    #[allow(deprecated)]
12253    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12254    where
12255        S: serde::Serializer,
12256    {
12257        use serde::ser::SerializeStruct;
12258        let mut len = 0;
12259        if !self.worker_slot_migration_plan.is_empty() {
12260            len += 1;
12261        }
12262        let mut struct_ser = serializer.serialize_struct("meta.MigrationPlan", len)?;
12263        if !self.worker_slot_migration_plan.is_empty() {
12264            let v: std::collections::HashMap<_, _> = self.worker_slot_migration_plan.iter()
12265                .map(|(k, v)| (k, v.to_string())).collect();
12266            struct_ser.serialize_field("workerSlotMigrationPlan", &v)?;
12267        }
12268        struct_ser.end()
12269    }
12270}
12271impl<'de> serde::Deserialize<'de> for MigrationPlan {
12272    #[allow(deprecated)]
12273    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12274    where
12275        D: serde::Deserializer<'de>,
12276    {
12277        const FIELDS: &[&str] = &[
12278            "worker_slot_migration_plan",
12279            "workerSlotMigrationPlan",
12280        ];
12281
12282        #[allow(clippy::enum_variant_names)]
12283        enum GeneratedField {
12284            WorkerSlotMigrationPlan,
12285        }
12286        impl<'de> serde::Deserialize<'de> for GeneratedField {
12287            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12288            where
12289                D: serde::Deserializer<'de>,
12290            {
12291                struct GeneratedVisitor;
12292
12293                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12294                    type Value = GeneratedField;
12295
12296                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12297                        write!(formatter, "expected one of: {:?}", &FIELDS)
12298                    }
12299
12300                    #[allow(unused_variables)]
12301                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12302                    where
12303                        E: serde::de::Error,
12304                    {
12305                        match value {
12306                            "workerSlotMigrationPlan" | "worker_slot_migration_plan" => Ok(GeneratedField::WorkerSlotMigrationPlan),
12307                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12308                        }
12309                    }
12310                }
12311                deserializer.deserialize_identifier(GeneratedVisitor)
12312            }
12313        }
12314        struct GeneratedVisitor;
12315        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12316            type Value = MigrationPlan;
12317
12318            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12319                formatter.write_str("struct meta.MigrationPlan")
12320            }
12321
12322            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MigrationPlan, V::Error>
12323                where
12324                    V: serde::de::MapAccess<'de>,
12325            {
12326                let mut worker_slot_migration_plan__ = None;
12327                while let Some(k) = map_.next_key()? {
12328                    match k {
12329                        GeneratedField::WorkerSlotMigrationPlan => {
12330                            if worker_slot_migration_plan__.is_some() {
12331                                return Err(serde::de::Error::duplicate_field("workerSlotMigrationPlan"));
12332                            }
12333                            worker_slot_migration_plan__ = Some(
12334                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u64>, ::pbjson::private::NumberDeserialize<u64>>>()?
12335                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
12336                            );
12337                        }
12338                    }
12339                }
12340                Ok(MigrationPlan {
12341                    worker_slot_migration_plan: worker_slot_migration_plan__.unwrap_or_default(),
12342                })
12343            }
12344        }
12345        deserializer.deserialize_struct("meta.MigrationPlan", FIELDS, GeneratedVisitor)
12346    }
12347}
12348impl serde::Serialize for Object {
12349    #[allow(deprecated)]
12350    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12351    where
12352        S: serde::Serializer,
12353    {
12354        use serde::ser::SerializeStruct;
12355        let mut len = 0;
12356        if self.object_info.is_some() {
12357            len += 1;
12358        }
12359        let mut struct_ser = serializer.serialize_struct("meta.Object", len)?;
12360        if let Some(v) = self.object_info.as_ref() {
12361            match v {
12362                object::ObjectInfo::Database(v) => {
12363                    struct_ser.serialize_field("database", v)?;
12364                }
12365                object::ObjectInfo::Schema(v) => {
12366                    struct_ser.serialize_field("schema", v)?;
12367                }
12368                object::ObjectInfo::Table(v) => {
12369                    struct_ser.serialize_field("table", v)?;
12370                }
12371                object::ObjectInfo::Index(v) => {
12372                    struct_ser.serialize_field("index", v)?;
12373                }
12374                object::ObjectInfo::Source(v) => {
12375                    struct_ser.serialize_field("source", v)?;
12376                }
12377                object::ObjectInfo::Sink(v) => {
12378                    struct_ser.serialize_field("sink", v)?;
12379                }
12380                object::ObjectInfo::View(v) => {
12381                    struct_ser.serialize_field("view", v)?;
12382                }
12383                object::ObjectInfo::Function(v) => {
12384                    struct_ser.serialize_field("function", v)?;
12385                }
12386                object::ObjectInfo::Connection(v) => {
12387                    struct_ser.serialize_field("connection", v)?;
12388                }
12389                object::ObjectInfo::Subscription(v) => {
12390                    struct_ser.serialize_field("subscription", v)?;
12391                }
12392                object::ObjectInfo::Secret(v) => {
12393                    struct_ser.serialize_field("secret", v)?;
12394                }
12395            }
12396        }
12397        struct_ser.end()
12398    }
12399}
12400impl<'de> serde::Deserialize<'de> for Object {
12401    #[allow(deprecated)]
12402    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12403    where
12404        D: serde::Deserializer<'de>,
12405    {
12406        const FIELDS: &[&str] = &[
12407            "database",
12408            "schema",
12409            "table",
12410            "index",
12411            "source",
12412            "sink",
12413            "view",
12414            "function",
12415            "connection",
12416            "subscription",
12417            "secret",
12418        ];
12419
12420        #[allow(clippy::enum_variant_names)]
12421        enum GeneratedField {
12422            Database,
12423            Schema,
12424            Table,
12425            Index,
12426            Source,
12427            Sink,
12428            View,
12429            Function,
12430            Connection,
12431            Subscription,
12432            Secret,
12433        }
12434        impl<'de> serde::Deserialize<'de> for GeneratedField {
12435            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12436            where
12437                D: serde::Deserializer<'de>,
12438            {
12439                struct GeneratedVisitor;
12440
12441                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12442                    type Value = GeneratedField;
12443
12444                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12445                        write!(formatter, "expected one of: {:?}", &FIELDS)
12446                    }
12447
12448                    #[allow(unused_variables)]
12449                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12450                    where
12451                        E: serde::de::Error,
12452                    {
12453                        match value {
12454                            "database" => Ok(GeneratedField::Database),
12455                            "schema" => Ok(GeneratedField::Schema),
12456                            "table" => Ok(GeneratedField::Table),
12457                            "index" => Ok(GeneratedField::Index),
12458                            "source" => Ok(GeneratedField::Source),
12459                            "sink" => Ok(GeneratedField::Sink),
12460                            "view" => Ok(GeneratedField::View),
12461                            "function" => Ok(GeneratedField::Function),
12462                            "connection" => Ok(GeneratedField::Connection),
12463                            "subscription" => Ok(GeneratedField::Subscription),
12464                            "secret" => Ok(GeneratedField::Secret),
12465                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12466                        }
12467                    }
12468                }
12469                deserializer.deserialize_identifier(GeneratedVisitor)
12470            }
12471        }
12472        struct GeneratedVisitor;
12473        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12474            type Value = Object;
12475
12476            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12477                formatter.write_str("struct meta.Object")
12478            }
12479
12480            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Object, V::Error>
12481                where
12482                    V: serde::de::MapAccess<'de>,
12483            {
12484                let mut object_info__ = None;
12485                while let Some(k) = map_.next_key()? {
12486                    match k {
12487                        GeneratedField::Database => {
12488                            if object_info__.is_some() {
12489                                return Err(serde::de::Error::duplicate_field("database"));
12490                            }
12491                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Database)
12492;
12493                        }
12494                        GeneratedField::Schema => {
12495                            if object_info__.is_some() {
12496                                return Err(serde::de::Error::duplicate_field("schema"));
12497                            }
12498                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Schema)
12499;
12500                        }
12501                        GeneratedField::Table => {
12502                            if object_info__.is_some() {
12503                                return Err(serde::de::Error::duplicate_field("table"));
12504                            }
12505                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Table)
12506;
12507                        }
12508                        GeneratedField::Index => {
12509                            if object_info__.is_some() {
12510                                return Err(serde::de::Error::duplicate_field("index"));
12511                            }
12512                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Index)
12513;
12514                        }
12515                        GeneratedField::Source => {
12516                            if object_info__.is_some() {
12517                                return Err(serde::de::Error::duplicate_field("source"));
12518                            }
12519                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Source)
12520;
12521                        }
12522                        GeneratedField::Sink => {
12523                            if object_info__.is_some() {
12524                                return Err(serde::de::Error::duplicate_field("sink"));
12525                            }
12526                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Sink)
12527;
12528                        }
12529                        GeneratedField::View => {
12530                            if object_info__.is_some() {
12531                                return Err(serde::de::Error::duplicate_field("view"));
12532                            }
12533                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::View)
12534;
12535                        }
12536                        GeneratedField::Function => {
12537                            if object_info__.is_some() {
12538                                return Err(serde::de::Error::duplicate_field("function"));
12539                            }
12540                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Function)
12541;
12542                        }
12543                        GeneratedField::Connection => {
12544                            if object_info__.is_some() {
12545                                return Err(serde::de::Error::duplicate_field("connection"));
12546                            }
12547                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Connection)
12548;
12549                        }
12550                        GeneratedField::Subscription => {
12551                            if object_info__.is_some() {
12552                                return Err(serde::de::Error::duplicate_field("subscription"));
12553                            }
12554                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Subscription)
12555;
12556                        }
12557                        GeneratedField::Secret => {
12558                            if object_info__.is_some() {
12559                                return Err(serde::de::Error::duplicate_field("secret"));
12560                            }
12561                            object_info__ = map_.next_value::<::std::option::Option<_>>()?.map(object::ObjectInfo::Secret)
12562;
12563                        }
12564                    }
12565                }
12566                Ok(Object {
12567                    object_info: object_info__,
12568                })
12569            }
12570        }
12571        deserializer.deserialize_struct("meta.Object", FIELDS, GeneratedVisitor)
12572    }
12573}
12574impl serde::Serialize for ObjectGroup {
12575    #[allow(deprecated)]
12576    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12577    where
12578        S: serde::Serializer,
12579    {
12580        use serde::ser::SerializeStruct;
12581        let mut len = 0;
12582        if !self.objects.is_empty() {
12583            len += 1;
12584        }
12585        let mut struct_ser = serializer.serialize_struct("meta.ObjectGroup", len)?;
12586        if !self.objects.is_empty() {
12587            struct_ser.serialize_field("objects", &self.objects)?;
12588        }
12589        struct_ser.end()
12590    }
12591}
12592impl<'de> serde::Deserialize<'de> for ObjectGroup {
12593    #[allow(deprecated)]
12594    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12595    where
12596        D: serde::Deserializer<'de>,
12597    {
12598        const FIELDS: &[&str] = &[
12599            "objects",
12600        ];
12601
12602        #[allow(clippy::enum_variant_names)]
12603        enum GeneratedField {
12604            Objects,
12605        }
12606        impl<'de> serde::Deserialize<'de> for GeneratedField {
12607            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12608            where
12609                D: serde::Deserializer<'de>,
12610            {
12611                struct GeneratedVisitor;
12612
12613                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12614                    type Value = GeneratedField;
12615
12616                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12617                        write!(formatter, "expected one of: {:?}", &FIELDS)
12618                    }
12619
12620                    #[allow(unused_variables)]
12621                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12622                    where
12623                        E: serde::de::Error,
12624                    {
12625                        match value {
12626                            "objects" => Ok(GeneratedField::Objects),
12627                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12628                        }
12629                    }
12630                }
12631                deserializer.deserialize_identifier(GeneratedVisitor)
12632            }
12633        }
12634        struct GeneratedVisitor;
12635        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12636            type Value = ObjectGroup;
12637
12638            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12639                formatter.write_str("struct meta.ObjectGroup")
12640            }
12641
12642            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ObjectGroup, V::Error>
12643                where
12644                    V: serde::de::MapAccess<'de>,
12645            {
12646                let mut objects__ = None;
12647                while let Some(k) = map_.next_key()? {
12648                    match k {
12649                        GeneratedField::Objects => {
12650                            if objects__.is_some() {
12651                                return Err(serde::de::Error::duplicate_field("objects"));
12652                            }
12653                            objects__ = Some(map_.next_value()?);
12654                        }
12655                    }
12656                }
12657                Ok(ObjectGroup {
12658                    objects: objects__.unwrap_or_default(),
12659                })
12660            }
12661        }
12662        deserializer.deserialize_struct("meta.ObjectGroup", FIELDS, GeneratedVisitor)
12663    }
12664}
12665impl serde::Serialize for PauseRequest {
12666    #[allow(deprecated)]
12667    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12668    where
12669        S: serde::Serializer,
12670    {
12671        use serde::ser::SerializeStruct;
12672        let len = 0;
12673        let struct_ser = serializer.serialize_struct("meta.PauseRequest", len)?;
12674        struct_ser.end()
12675    }
12676}
12677impl<'de> serde::Deserialize<'de> for PauseRequest {
12678    #[allow(deprecated)]
12679    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12680    where
12681        D: serde::Deserializer<'de>,
12682    {
12683        const FIELDS: &[&str] = &[
12684        ];
12685
12686        #[allow(clippy::enum_variant_names)]
12687        enum GeneratedField {
12688        }
12689        impl<'de> serde::Deserialize<'de> for GeneratedField {
12690            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12691            where
12692                D: serde::Deserializer<'de>,
12693            {
12694                struct GeneratedVisitor;
12695
12696                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12697                    type Value = GeneratedField;
12698
12699                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12700                        write!(formatter, "expected one of: {:?}", &FIELDS)
12701                    }
12702
12703                    #[allow(unused_variables)]
12704                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12705                    where
12706                        E: serde::de::Error,
12707                    {
12708                            Err(serde::de::Error::unknown_field(value, FIELDS))
12709                    }
12710                }
12711                deserializer.deserialize_identifier(GeneratedVisitor)
12712            }
12713        }
12714        struct GeneratedVisitor;
12715        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12716            type Value = PauseRequest;
12717
12718            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12719                formatter.write_str("struct meta.PauseRequest")
12720            }
12721
12722            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseRequest, V::Error>
12723                where
12724                    V: serde::de::MapAccess<'de>,
12725            {
12726                while map_.next_key::<GeneratedField>()?.is_some() {
12727                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12728                }
12729                Ok(PauseRequest {
12730                })
12731            }
12732        }
12733        deserializer.deserialize_struct("meta.PauseRequest", FIELDS, GeneratedVisitor)
12734    }
12735}
12736impl serde::Serialize for PauseResponse {
12737    #[allow(deprecated)]
12738    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12739    where
12740        S: serde::Serializer,
12741    {
12742        use serde::ser::SerializeStruct;
12743        let len = 0;
12744        let struct_ser = serializer.serialize_struct("meta.PauseResponse", len)?;
12745        struct_ser.end()
12746    }
12747}
12748impl<'de> serde::Deserialize<'de> for PauseResponse {
12749    #[allow(deprecated)]
12750    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12751    where
12752        D: serde::Deserializer<'de>,
12753    {
12754        const FIELDS: &[&str] = &[
12755        ];
12756
12757        #[allow(clippy::enum_variant_names)]
12758        enum GeneratedField {
12759        }
12760        impl<'de> serde::Deserialize<'de> for GeneratedField {
12761            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12762            where
12763                D: serde::Deserializer<'de>,
12764            {
12765                struct GeneratedVisitor;
12766
12767                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12768                    type Value = GeneratedField;
12769
12770                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12771                        write!(formatter, "expected one of: {:?}", &FIELDS)
12772                    }
12773
12774                    #[allow(unused_variables)]
12775                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12776                    where
12777                        E: serde::de::Error,
12778                    {
12779                            Err(serde::de::Error::unknown_field(value, FIELDS))
12780                    }
12781                }
12782                deserializer.deserialize_identifier(GeneratedVisitor)
12783            }
12784        }
12785        struct GeneratedVisitor;
12786        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12787            type Value = PauseResponse;
12788
12789            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12790                formatter.write_str("struct meta.PauseResponse")
12791            }
12792
12793            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseResponse, V::Error>
12794                where
12795                    V: serde::de::MapAccess<'de>,
12796            {
12797                while map_.next_key::<GeneratedField>()?.is_some() {
12798                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12799                }
12800                Ok(PauseResponse {
12801                })
12802            }
12803        }
12804        deserializer.deserialize_struct("meta.PauseResponse", FIELDS, GeneratedVisitor)
12805    }
12806}
12807impl serde::Serialize for RecoverRequest {
12808    #[allow(deprecated)]
12809    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12810    where
12811        S: serde::Serializer,
12812    {
12813        use serde::ser::SerializeStruct;
12814        let len = 0;
12815        let struct_ser = serializer.serialize_struct("meta.RecoverRequest", len)?;
12816        struct_ser.end()
12817    }
12818}
12819impl<'de> serde::Deserialize<'de> for RecoverRequest {
12820    #[allow(deprecated)]
12821    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12822    where
12823        D: serde::Deserializer<'de>,
12824    {
12825        const FIELDS: &[&str] = &[
12826        ];
12827
12828        #[allow(clippy::enum_variant_names)]
12829        enum GeneratedField {
12830        }
12831        impl<'de> serde::Deserialize<'de> for GeneratedField {
12832            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12833            where
12834                D: serde::Deserializer<'de>,
12835            {
12836                struct GeneratedVisitor;
12837
12838                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12839                    type Value = GeneratedField;
12840
12841                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12842                        write!(formatter, "expected one of: {:?}", &FIELDS)
12843                    }
12844
12845                    #[allow(unused_variables)]
12846                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12847                    where
12848                        E: serde::de::Error,
12849                    {
12850                            Err(serde::de::Error::unknown_field(value, FIELDS))
12851                    }
12852                }
12853                deserializer.deserialize_identifier(GeneratedVisitor)
12854            }
12855        }
12856        struct GeneratedVisitor;
12857        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12858            type Value = RecoverRequest;
12859
12860            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12861                formatter.write_str("struct meta.RecoverRequest")
12862            }
12863
12864            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverRequest, V::Error>
12865                where
12866                    V: serde::de::MapAccess<'de>,
12867            {
12868                while map_.next_key::<GeneratedField>()?.is_some() {
12869                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12870                }
12871                Ok(RecoverRequest {
12872                })
12873            }
12874        }
12875        deserializer.deserialize_struct("meta.RecoverRequest", FIELDS, GeneratedVisitor)
12876    }
12877}
12878impl serde::Serialize for RecoverResponse {
12879    #[allow(deprecated)]
12880    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12881    where
12882        S: serde::Serializer,
12883    {
12884        use serde::ser::SerializeStruct;
12885        let len = 0;
12886        let struct_ser = serializer.serialize_struct("meta.RecoverResponse", len)?;
12887        struct_ser.end()
12888    }
12889}
12890impl<'de> serde::Deserialize<'de> for RecoverResponse {
12891    #[allow(deprecated)]
12892    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12893    where
12894        D: serde::Deserializer<'de>,
12895    {
12896        const FIELDS: &[&str] = &[
12897        ];
12898
12899        #[allow(clippy::enum_variant_names)]
12900        enum GeneratedField {
12901        }
12902        impl<'de> serde::Deserialize<'de> for GeneratedField {
12903            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12904            where
12905                D: serde::Deserializer<'de>,
12906            {
12907                struct GeneratedVisitor;
12908
12909                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12910                    type Value = GeneratedField;
12911
12912                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12913                        write!(formatter, "expected one of: {:?}", &FIELDS)
12914                    }
12915
12916                    #[allow(unused_variables)]
12917                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12918                    where
12919                        E: serde::de::Error,
12920                    {
12921                            Err(serde::de::Error::unknown_field(value, FIELDS))
12922                    }
12923                }
12924                deserializer.deserialize_identifier(GeneratedVisitor)
12925            }
12926        }
12927        struct GeneratedVisitor;
12928        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12929            type Value = RecoverResponse;
12930
12931            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12932                formatter.write_str("struct meta.RecoverResponse")
12933            }
12934
12935            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RecoverResponse, V::Error>
12936                where
12937                    V: serde::de::MapAccess<'de>,
12938            {
12939                while map_.next_key::<GeneratedField>()?.is_some() {
12940                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
12941                }
12942                Ok(RecoverResponse {
12943                })
12944            }
12945        }
12946        deserializer.deserialize_struct("meta.RecoverResponse", FIELDS, GeneratedVisitor)
12947    }
12948}
12949impl serde::Serialize for Recovery {
12950    #[allow(deprecated)]
12951    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12952    where
12953        S: serde::Serializer,
12954    {
12955        use serde::ser::SerializeStruct;
12956        let len = 0;
12957        let struct_ser = serializer.serialize_struct("meta.Recovery", len)?;
12958        struct_ser.end()
12959    }
12960}
12961impl<'de> serde::Deserialize<'de> for Recovery {
12962    #[allow(deprecated)]
12963    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12964    where
12965        D: serde::Deserializer<'de>,
12966    {
12967        const FIELDS: &[&str] = &[
12968        ];
12969
12970        #[allow(clippy::enum_variant_names)]
12971        enum GeneratedField {
12972        }
12973        impl<'de> serde::Deserialize<'de> for GeneratedField {
12974            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12975            where
12976                D: serde::Deserializer<'de>,
12977            {
12978                struct GeneratedVisitor;
12979
12980                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12981                    type Value = GeneratedField;
12982
12983                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12984                        write!(formatter, "expected one of: {:?}", &FIELDS)
12985                    }
12986
12987                    #[allow(unused_variables)]
12988                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12989                    where
12990                        E: serde::de::Error,
12991                    {
12992                            Err(serde::de::Error::unknown_field(value, FIELDS))
12993                    }
12994                }
12995                deserializer.deserialize_identifier(GeneratedVisitor)
12996            }
12997        }
12998        struct GeneratedVisitor;
12999        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13000            type Value = Recovery;
13001
13002            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13003                formatter.write_str("struct meta.Recovery")
13004            }
13005
13006            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Recovery, V::Error>
13007                where
13008                    V: serde::de::MapAccess<'de>,
13009            {
13010                while map_.next_key::<GeneratedField>()?.is_some() {
13011                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13012                }
13013                Ok(Recovery {
13014                })
13015            }
13016        }
13017        deserializer.deserialize_struct("meta.Recovery", FIELDS, GeneratedVisitor)
13018    }
13019}
13020impl serde::Serialize for RecoveryStatus {
13021    #[allow(deprecated)]
13022    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13023    where
13024        S: serde::Serializer,
13025    {
13026        let variant = match self {
13027            Self::StatusUnspecified => "STATUS_UNSPECIFIED",
13028            Self::StatusStarting => "STATUS_STARTING",
13029            Self::StatusRecovering => "STATUS_RECOVERING",
13030            Self::StatusRunning => "STATUS_RUNNING",
13031        };
13032        serializer.serialize_str(variant)
13033    }
13034}
13035impl<'de> serde::Deserialize<'de> for RecoveryStatus {
13036    #[allow(deprecated)]
13037    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13038    where
13039        D: serde::Deserializer<'de>,
13040    {
13041        const FIELDS: &[&str] = &[
13042            "STATUS_UNSPECIFIED",
13043            "STATUS_STARTING",
13044            "STATUS_RECOVERING",
13045            "STATUS_RUNNING",
13046        ];
13047
13048        struct GeneratedVisitor;
13049
13050        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13051            type Value = RecoveryStatus;
13052
13053            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13054                write!(formatter, "expected one of: {:?}", &FIELDS)
13055            }
13056
13057            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13058            where
13059                E: serde::de::Error,
13060            {
13061                i32::try_from(v)
13062                    .ok()
13063                    .and_then(|x| x.try_into().ok())
13064                    .ok_or_else(|| {
13065                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13066                    })
13067            }
13068
13069            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13070            where
13071                E: serde::de::Error,
13072            {
13073                i32::try_from(v)
13074                    .ok()
13075                    .and_then(|x| x.try_into().ok())
13076                    .ok_or_else(|| {
13077                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13078                    })
13079            }
13080
13081            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13082            where
13083                E: serde::de::Error,
13084            {
13085                match value {
13086                    "STATUS_UNSPECIFIED" => Ok(RecoveryStatus::StatusUnspecified),
13087                    "STATUS_STARTING" => Ok(RecoveryStatus::StatusStarting),
13088                    "STATUS_RECOVERING" => Ok(RecoveryStatus::StatusRecovering),
13089                    "STATUS_RUNNING" => Ok(RecoveryStatus::StatusRunning),
13090                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13091                }
13092            }
13093        }
13094        deserializer.deserialize_any(GeneratedVisitor)
13095    }
13096}
13097impl serde::Serialize for RefreshRequest {
13098    #[allow(deprecated)]
13099    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13100    where
13101        S: serde::Serializer,
13102    {
13103        use serde::ser::SerializeStruct;
13104        let mut len = 0;
13105        if self.table_id != 0 {
13106            len += 1;
13107        }
13108        if self.associated_source_id != 0 {
13109            len += 1;
13110        }
13111        let mut struct_ser = serializer.serialize_struct("meta.RefreshRequest", len)?;
13112        if self.table_id != 0 {
13113            struct_ser.serialize_field("tableId", &self.table_id)?;
13114        }
13115        if self.associated_source_id != 0 {
13116            struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
13117        }
13118        struct_ser.end()
13119    }
13120}
13121impl<'de> serde::Deserialize<'de> for RefreshRequest {
13122    #[allow(deprecated)]
13123    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13124    where
13125        D: serde::Deserializer<'de>,
13126    {
13127        const FIELDS: &[&str] = &[
13128            "table_id",
13129            "tableId",
13130            "associated_source_id",
13131            "associatedSourceId",
13132        ];
13133
13134        #[allow(clippy::enum_variant_names)]
13135        enum GeneratedField {
13136            TableId,
13137            AssociatedSourceId,
13138        }
13139        impl<'de> serde::Deserialize<'de> for GeneratedField {
13140            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13141            where
13142                D: serde::Deserializer<'de>,
13143            {
13144                struct GeneratedVisitor;
13145
13146                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13147                    type Value = GeneratedField;
13148
13149                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13150                        write!(formatter, "expected one of: {:?}", &FIELDS)
13151                    }
13152
13153                    #[allow(unused_variables)]
13154                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13155                    where
13156                        E: serde::de::Error,
13157                    {
13158                        match value {
13159                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
13160                            "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
13161                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13162                        }
13163                    }
13164                }
13165                deserializer.deserialize_identifier(GeneratedVisitor)
13166            }
13167        }
13168        struct GeneratedVisitor;
13169        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13170            type Value = RefreshRequest;
13171
13172            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13173                formatter.write_str("struct meta.RefreshRequest")
13174            }
13175
13176            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshRequest, V::Error>
13177                where
13178                    V: serde::de::MapAccess<'de>,
13179            {
13180                let mut table_id__ = None;
13181                let mut associated_source_id__ = None;
13182                while let Some(k) = map_.next_key()? {
13183                    match k {
13184                        GeneratedField::TableId => {
13185                            if table_id__.is_some() {
13186                                return Err(serde::de::Error::duplicate_field("tableId"));
13187                            }
13188                            table_id__ = 
13189                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13190                            ;
13191                        }
13192                        GeneratedField::AssociatedSourceId => {
13193                            if associated_source_id__.is_some() {
13194                                return Err(serde::de::Error::duplicate_field("associatedSourceId"));
13195                            }
13196                            associated_source_id__ = 
13197                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13198                            ;
13199                        }
13200                    }
13201                }
13202                Ok(RefreshRequest {
13203                    table_id: table_id__.unwrap_or_default(),
13204                    associated_source_id: associated_source_id__.unwrap_or_default(),
13205                })
13206            }
13207        }
13208        deserializer.deserialize_struct("meta.RefreshRequest", FIELDS, GeneratedVisitor)
13209    }
13210}
13211impl serde::Serialize for RefreshResponse {
13212    #[allow(deprecated)]
13213    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13214    where
13215        S: serde::Serializer,
13216    {
13217        use serde::ser::SerializeStruct;
13218        let mut len = 0;
13219        if self.status.is_some() {
13220            len += 1;
13221        }
13222        let mut struct_ser = serializer.serialize_struct("meta.RefreshResponse", len)?;
13223        if let Some(v) = self.status.as_ref() {
13224            struct_ser.serialize_field("status", v)?;
13225        }
13226        struct_ser.end()
13227    }
13228}
13229impl<'de> serde::Deserialize<'de> for RefreshResponse {
13230    #[allow(deprecated)]
13231    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13232    where
13233        D: serde::Deserializer<'de>,
13234    {
13235        const FIELDS: &[&str] = &[
13236            "status",
13237        ];
13238
13239        #[allow(clippy::enum_variant_names)]
13240        enum GeneratedField {
13241            Status,
13242        }
13243        impl<'de> serde::Deserialize<'de> for GeneratedField {
13244            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13245            where
13246                D: serde::Deserializer<'de>,
13247            {
13248                struct GeneratedVisitor;
13249
13250                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13251                    type Value = GeneratedField;
13252
13253                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13254                        write!(formatter, "expected one of: {:?}", &FIELDS)
13255                    }
13256
13257                    #[allow(unused_variables)]
13258                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13259                    where
13260                        E: serde::de::Error,
13261                    {
13262                        match value {
13263                            "status" => Ok(GeneratedField::Status),
13264                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13265                        }
13266                    }
13267                }
13268                deserializer.deserialize_identifier(GeneratedVisitor)
13269            }
13270        }
13271        struct GeneratedVisitor;
13272        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13273            type Value = RefreshResponse;
13274
13275            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13276                formatter.write_str("struct meta.RefreshResponse")
13277            }
13278
13279            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshResponse, V::Error>
13280                where
13281                    V: serde::de::MapAccess<'de>,
13282            {
13283                let mut status__ = None;
13284                while let Some(k) = map_.next_key()? {
13285                    match k {
13286                        GeneratedField::Status => {
13287                            if status__.is_some() {
13288                                return Err(serde::de::Error::duplicate_field("status"));
13289                            }
13290                            status__ = map_.next_value()?;
13291                        }
13292                    }
13293                }
13294                Ok(RefreshResponse {
13295                    status: status__,
13296                })
13297            }
13298        }
13299        deserializer.deserialize_struct("meta.RefreshResponse", FIELDS, GeneratedVisitor)
13300    }
13301}
13302impl serde::Serialize for RelationIdInfos {
13303    #[allow(deprecated)]
13304    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13305    where
13306        S: serde::Serializer,
13307    {
13308        use serde::ser::SerializeStruct;
13309        let mut len = 0;
13310        if !self.map.is_empty() {
13311            len += 1;
13312        }
13313        let mut struct_ser = serializer.serialize_struct("meta.RelationIdInfos", len)?;
13314        if !self.map.is_empty() {
13315            struct_ser.serialize_field("map", &self.map)?;
13316        }
13317        struct_ser.end()
13318    }
13319}
13320impl<'de> serde::Deserialize<'de> for RelationIdInfos {
13321    #[allow(deprecated)]
13322    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13323    where
13324        D: serde::Deserializer<'de>,
13325    {
13326        const FIELDS: &[&str] = &[
13327            "map",
13328        ];
13329
13330        #[allow(clippy::enum_variant_names)]
13331        enum GeneratedField {
13332            Map,
13333        }
13334        impl<'de> serde::Deserialize<'de> for GeneratedField {
13335            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13336            where
13337                D: serde::Deserializer<'de>,
13338            {
13339                struct GeneratedVisitor;
13340
13341                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13342                    type Value = GeneratedField;
13343
13344                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13345                        write!(formatter, "expected one of: {:?}", &FIELDS)
13346                    }
13347
13348                    #[allow(unused_variables)]
13349                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13350                    where
13351                        E: serde::de::Error,
13352                    {
13353                        match value {
13354                            "map" => Ok(GeneratedField::Map),
13355                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13356                        }
13357                    }
13358                }
13359                deserializer.deserialize_identifier(GeneratedVisitor)
13360            }
13361        }
13362        struct GeneratedVisitor;
13363        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13364            type Value = RelationIdInfos;
13365
13366            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13367                formatter.write_str("struct meta.RelationIdInfos")
13368            }
13369
13370            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RelationIdInfos, V::Error>
13371                where
13372                    V: serde::de::MapAccess<'de>,
13373            {
13374                let mut map__ = None;
13375                while let Some(k) = map_.next_key()? {
13376                    match k {
13377                        GeneratedField::Map => {
13378                            if map__.is_some() {
13379                                return Err(serde::de::Error::duplicate_field("map"));
13380                            }
13381                            map__ = Some(
13382                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13383                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
13384                            );
13385                        }
13386                    }
13387                }
13388                Ok(RelationIdInfos {
13389                    map: map__.unwrap_or_default(),
13390                })
13391            }
13392        }
13393        deserializer.deserialize_struct("meta.RelationIdInfos", FIELDS, GeneratedVisitor)
13394    }
13395}
13396impl serde::Serialize for RescheduleRequest {
13397    #[allow(deprecated)]
13398    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13399    where
13400        S: serde::Serializer,
13401    {
13402        use serde::ser::SerializeStruct;
13403        let mut len = 0;
13404        if self.revision != 0 {
13405            len += 1;
13406        }
13407        if self.resolve_no_shuffle_upstream {
13408            len += 1;
13409        }
13410        if !self.worker_reschedules.is_empty() {
13411            len += 1;
13412        }
13413        let mut struct_ser = serializer.serialize_struct("meta.RescheduleRequest", len)?;
13414        if self.revision != 0 {
13415            #[allow(clippy::needless_borrow)]
13416            #[allow(clippy::needless_borrows_for_generic_args)]
13417            struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
13418        }
13419        if self.resolve_no_shuffle_upstream {
13420            struct_ser.serialize_field("resolveNoShuffleUpstream", &self.resolve_no_shuffle_upstream)?;
13421        }
13422        if !self.worker_reschedules.is_empty() {
13423            struct_ser.serialize_field("workerReschedules", &self.worker_reschedules)?;
13424        }
13425        struct_ser.end()
13426    }
13427}
13428impl<'de> serde::Deserialize<'de> for RescheduleRequest {
13429    #[allow(deprecated)]
13430    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13431    where
13432        D: serde::Deserializer<'de>,
13433    {
13434        const FIELDS: &[&str] = &[
13435            "revision",
13436            "resolve_no_shuffle_upstream",
13437            "resolveNoShuffleUpstream",
13438            "worker_reschedules",
13439            "workerReschedules",
13440        ];
13441
13442        #[allow(clippy::enum_variant_names)]
13443        enum GeneratedField {
13444            Revision,
13445            ResolveNoShuffleUpstream,
13446            WorkerReschedules,
13447        }
13448        impl<'de> serde::Deserialize<'de> for GeneratedField {
13449            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13450            where
13451                D: serde::Deserializer<'de>,
13452            {
13453                struct GeneratedVisitor;
13454
13455                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13456                    type Value = GeneratedField;
13457
13458                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13459                        write!(formatter, "expected one of: {:?}", &FIELDS)
13460                    }
13461
13462                    #[allow(unused_variables)]
13463                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13464                    where
13465                        E: serde::de::Error,
13466                    {
13467                        match value {
13468                            "revision" => Ok(GeneratedField::Revision),
13469                            "resolveNoShuffleUpstream" | "resolve_no_shuffle_upstream" => Ok(GeneratedField::ResolveNoShuffleUpstream),
13470                            "workerReschedules" | "worker_reschedules" => Ok(GeneratedField::WorkerReschedules),
13471                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13472                        }
13473                    }
13474                }
13475                deserializer.deserialize_identifier(GeneratedVisitor)
13476            }
13477        }
13478        struct GeneratedVisitor;
13479        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13480            type Value = RescheduleRequest;
13481
13482            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13483                formatter.write_str("struct meta.RescheduleRequest")
13484            }
13485
13486            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleRequest, V::Error>
13487                where
13488                    V: serde::de::MapAccess<'de>,
13489            {
13490                let mut revision__ = None;
13491                let mut resolve_no_shuffle_upstream__ = None;
13492                let mut worker_reschedules__ = None;
13493                while let Some(k) = map_.next_key()? {
13494                    match k {
13495                        GeneratedField::Revision => {
13496                            if revision__.is_some() {
13497                                return Err(serde::de::Error::duplicate_field("revision"));
13498                            }
13499                            revision__ = 
13500                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13501                            ;
13502                        }
13503                        GeneratedField::ResolveNoShuffleUpstream => {
13504                            if resolve_no_shuffle_upstream__.is_some() {
13505                                return Err(serde::de::Error::duplicate_field("resolveNoShuffleUpstream"));
13506                            }
13507                            resolve_no_shuffle_upstream__ = Some(map_.next_value()?);
13508                        }
13509                        GeneratedField::WorkerReschedules => {
13510                            if worker_reschedules__.is_some() {
13511                                return Err(serde::de::Error::duplicate_field("workerReschedules"));
13512                            }
13513                            worker_reschedules__ = Some(
13514                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13515                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
13516                            );
13517                        }
13518                    }
13519                }
13520                Ok(RescheduleRequest {
13521                    revision: revision__.unwrap_or_default(),
13522                    resolve_no_shuffle_upstream: resolve_no_shuffle_upstream__.unwrap_or_default(),
13523                    worker_reschedules: worker_reschedules__.unwrap_or_default(),
13524                })
13525            }
13526        }
13527        deserializer.deserialize_struct("meta.RescheduleRequest", FIELDS, GeneratedVisitor)
13528    }
13529}
13530impl serde::Serialize for RescheduleResponse {
13531    #[allow(deprecated)]
13532    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13533    where
13534        S: serde::Serializer,
13535    {
13536        use serde::ser::SerializeStruct;
13537        let mut len = 0;
13538        if self.success {
13539            len += 1;
13540        }
13541        if self.revision != 0 {
13542            len += 1;
13543        }
13544        let mut struct_ser = serializer.serialize_struct("meta.RescheduleResponse", len)?;
13545        if self.success {
13546            struct_ser.serialize_field("success", &self.success)?;
13547        }
13548        if self.revision != 0 {
13549            #[allow(clippy::needless_borrow)]
13550            #[allow(clippy::needless_borrows_for_generic_args)]
13551            struct_ser.serialize_field("revision", ToString::to_string(&self.revision).as_str())?;
13552        }
13553        struct_ser.end()
13554    }
13555}
13556impl<'de> serde::Deserialize<'de> for RescheduleResponse {
13557    #[allow(deprecated)]
13558    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13559    where
13560        D: serde::Deserializer<'de>,
13561    {
13562        const FIELDS: &[&str] = &[
13563            "success",
13564            "revision",
13565        ];
13566
13567        #[allow(clippy::enum_variant_names)]
13568        enum GeneratedField {
13569            Success,
13570            Revision,
13571        }
13572        impl<'de> serde::Deserialize<'de> for GeneratedField {
13573            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13574            where
13575                D: serde::Deserializer<'de>,
13576            {
13577                struct GeneratedVisitor;
13578
13579                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13580                    type Value = GeneratedField;
13581
13582                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13583                        write!(formatter, "expected one of: {:?}", &FIELDS)
13584                    }
13585
13586                    #[allow(unused_variables)]
13587                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13588                    where
13589                        E: serde::de::Error,
13590                    {
13591                        match value {
13592                            "success" => Ok(GeneratedField::Success),
13593                            "revision" => Ok(GeneratedField::Revision),
13594                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13595                        }
13596                    }
13597                }
13598                deserializer.deserialize_identifier(GeneratedVisitor)
13599            }
13600        }
13601        struct GeneratedVisitor;
13602        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13603            type Value = RescheduleResponse;
13604
13605            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13606                formatter.write_str("struct meta.RescheduleResponse")
13607            }
13608
13609            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RescheduleResponse, V::Error>
13610                where
13611                    V: serde::de::MapAccess<'de>,
13612            {
13613                let mut success__ = None;
13614                let mut revision__ = None;
13615                while let Some(k) = map_.next_key()? {
13616                    match k {
13617                        GeneratedField::Success => {
13618                            if success__.is_some() {
13619                                return Err(serde::de::Error::duplicate_field("success"));
13620                            }
13621                            success__ = Some(map_.next_value()?);
13622                        }
13623                        GeneratedField::Revision => {
13624                            if revision__.is_some() {
13625                                return Err(serde::de::Error::duplicate_field("revision"));
13626                            }
13627                            revision__ = 
13628                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13629                            ;
13630                        }
13631                    }
13632                }
13633                Ok(RescheduleResponse {
13634                    success: success__.unwrap_or_default(),
13635                    revision: revision__.unwrap_or_default(),
13636                })
13637            }
13638        }
13639        deserializer.deserialize_struct("meta.RescheduleResponse", FIELDS, GeneratedVisitor)
13640    }
13641}
13642impl serde::Serialize for ResumeRequest {
13643    #[allow(deprecated)]
13644    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13645    where
13646        S: serde::Serializer,
13647    {
13648        use serde::ser::SerializeStruct;
13649        let len = 0;
13650        let struct_ser = serializer.serialize_struct("meta.ResumeRequest", len)?;
13651        struct_ser.end()
13652    }
13653}
13654impl<'de> serde::Deserialize<'de> for ResumeRequest {
13655    #[allow(deprecated)]
13656    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13657    where
13658        D: serde::Deserializer<'de>,
13659    {
13660        const FIELDS: &[&str] = &[
13661        ];
13662
13663        #[allow(clippy::enum_variant_names)]
13664        enum GeneratedField {
13665        }
13666        impl<'de> serde::Deserialize<'de> for GeneratedField {
13667            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13668            where
13669                D: serde::Deserializer<'de>,
13670            {
13671                struct GeneratedVisitor;
13672
13673                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13674                    type Value = GeneratedField;
13675
13676                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13677                        write!(formatter, "expected one of: {:?}", &FIELDS)
13678                    }
13679
13680                    #[allow(unused_variables)]
13681                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13682                    where
13683                        E: serde::de::Error,
13684                    {
13685                            Err(serde::de::Error::unknown_field(value, FIELDS))
13686                    }
13687                }
13688                deserializer.deserialize_identifier(GeneratedVisitor)
13689            }
13690        }
13691        struct GeneratedVisitor;
13692        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13693            type Value = ResumeRequest;
13694
13695            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13696                formatter.write_str("struct meta.ResumeRequest")
13697            }
13698
13699            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeRequest, V::Error>
13700                where
13701                    V: serde::de::MapAccess<'de>,
13702            {
13703                while map_.next_key::<GeneratedField>()?.is_some() {
13704                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13705                }
13706                Ok(ResumeRequest {
13707                })
13708            }
13709        }
13710        deserializer.deserialize_struct("meta.ResumeRequest", FIELDS, GeneratedVisitor)
13711    }
13712}
13713impl serde::Serialize for ResumeResponse {
13714    #[allow(deprecated)]
13715    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13716    where
13717        S: serde::Serializer,
13718    {
13719        use serde::ser::SerializeStruct;
13720        let len = 0;
13721        let struct_ser = serializer.serialize_struct("meta.ResumeResponse", len)?;
13722        struct_ser.end()
13723    }
13724}
13725impl<'de> serde::Deserialize<'de> for ResumeResponse {
13726    #[allow(deprecated)]
13727    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13728    where
13729        D: serde::Deserializer<'de>,
13730    {
13731        const FIELDS: &[&str] = &[
13732        ];
13733
13734        #[allow(clippy::enum_variant_names)]
13735        enum GeneratedField {
13736        }
13737        impl<'de> serde::Deserialize<'de> for GeneratedField {
13738            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13739            where
13740                D: serde::Deserializer<'de>,
13741            {
13742                struct GeneratedVisitor;
13743
13744                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13745                    type Value = GeneratedField;
13746
13747                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13748                        write!(formatter, "expected one of: {:?}", &FIELDS)
13749                    }
13750
13751                    #[allow(unused_variables)]
13752                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13753                    where
13754                        E: serde::de::Error,
13755                    {
13756                            Err(serde::de::Error::unknown_field(value, FIELDS))
13757                    }
13758                }
13759                deserializer.deserialize_identifier(GeneratedVisitor)
13760            }
13761        }
13762        struct GeneratedVisitor;
13763        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13764            type Value = ResumeResponse;
13765
13766            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13767                formatter.write_str("struct meta.ResumeResponse")
13768            }
13769
13770            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeResponse, V::Error>
13771                where
13772                    V: serde::de::MapAccess<'de>,
13773            {
13774                while map_.next_key::<GeneratedField>()?.is_some() {
13775                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13776                }
13777                Ok(ResumeResponse {
13778                })
13779            }
13780        }
13781        deserializer.deserialize_struct("meta.ResumeResponse", FIELDS, GeneratedVisitor)
13782    }
13783}
13784impl serde::Serialize for SetSessionParamRequest {
13785    #[allow(deprecated)]
13786    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13787    where
13788        S: serde::Serializer,
13789    {
13790        use serde::ser::SerializeStruct;
13791        let mut len = 0;
13792        if !self.param.is_empty() {
13793            len += 1;
13794        }
13795        if self.value.is_some() {
13796            len += 1;
13797        }
13798        let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamRequest", len)?;
13799        if !self.param.is_empty() {
13800            struct_ser.serialize_field("param", &self.param)?;
13801        }
13802        if let Some(v) = self.value.as_ref() {
13803            struct_ser.serialize_field("value", v)?;
13804        }
13805        struct_ser.end()
13806    }
13807}
13808impl<'de> serde::Deserialize<'de> for SetSessionParamRequest {
13809    #[allow(deprecated)]
13810    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13811    where
13812        D: serde::Deserializer<'de>,
13813    {
13814        const FIELDS: &[&str] = &[
13815            "param",
13816            "value",
13817        ];
13818
13819        #[allow(clippy::enum_variant_names)]
13820        enum GeneratedField {
13821            Param,
13822            Value,
13823        }
13824        impl<'de> serde::Deserialize<'de> for GeneratedField {
13825            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13826            where
13827                D: serde::Deserializer<'de>,
13828            {
13829                struct GeneratedVisitor;
13830
13831                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13832                    type Value = GeneratedField;
13833
13834                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13835                        write!(formatter, "expected one of: {:?}", &FIELDS)
13836                    }
13837
13838                    #[allow(unused_variables)]
13839                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13840                    where
13841                        E: serde::de::Error,
13842                    {
13843                        match value {
13844                            "param" => Ok(GeneratedField::Param),
13845                            "value" => Ok(GeneratedField::Value),
13846                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13847                        }
13848                    }
13849                }
13850                deserializer.deserialize_identifier(GeneratedVisitor)
13851            }
13852        }
13853        struct GeneratedVisitor;
13854        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13855            type Value = SetSessionParamRequest;
13856
13857            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13858                formatter.write_str("struct meta.SetSessionParamRequest")
13859            }
13860
13861            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamRequest, V::Error>
13862                where
13863                    V: serde::de::MapAccess<'de>,
13864            {
13865                let mut param__ = None;
13866                let mut value__ = None;
13867                while let Some(k) = map_.next_key()? {
13868                    match k {
13869                        GeneratedField::Param => {
13870                            if param__.is_some() {
13871                                return Err(serde::de::Error::duplicate_field("param"));
13872                            }
13873                            param__ = Some(map_.next_value()?);
13874                        }
13875                        GeneratedField::Value => {
13876                            if value__.is_some() {
13877                                return Err(serde::de::Error::duplicate_field("value"));
13878                            }
13879                            value__ = map_.next_value()?;
13880                        }
13881                    }
13882                }
13883                Ok(SetSessionParamRequest {
13884                    param: param__.unwrap_or_default(),
13885                    value: value__,
13886                })
13887            }
13888        }
13889        deserializer.deserialize_struct("meta.SetSessionParamRequest", FIELDS, GeneratedVisitor)
13890    }
13891}
13892impl serde::Serialize for SetSessionParamResponse {
13893    #[allow(deprecated)]
13894    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13895    where
13896        S: serde::Serializer,
13897    {
13898        use serde::ser::SerializeStruct;
13899        let mut len = 0;
13900        if !self.param.is_empty() {
13901            len += 1;
13902        }
13903        let mut struct_ser = serializer.serialize_struct("meta.SetSessionParamResponse", len)?;
13904        if !self.param.is_empty() {
13905            struct_ser.serialize_field("param", &self.param)?;
13906        }
13907        struct_ser.end()
13908    }
13909}
13910impl<'de> serde::Deserialize<'de> for SetSessionParamResponse {
13911    #[allow(deprecated)]
13912    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13913    where
13914        D: serde::Deserializer<'de>,
13915    {
13916        const FIELDS: &[&str] = &[
13917            "param",
13918        ];
13919
13920        #[allow(clippy::enum_variant_names)]
13921        enum GeneratedField {
13922            Param,
13923        }
13924        impl<'de> serde::Deserialize<'de> for GeneratedField {
13925            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13926            where
13927                D: serde::Deserializer<'de>,
13928            {
13929                struct GeneratedVisitor;
13930
13931                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13932                    type Value = GeneratedField;
13933
13934                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13935                        write!(formatter, "expected one of: {:?}", &FIELDS)
13936                    }
13937
13938                    #[allow(unused_variables)]
13939                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13940                    where
13941                        E: serde::de::Error,
13942                    {
13943                        match value {
13944                            "param" => Ok(GeneratedField::Param),
13945                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13946                        }
13947                    }
13948                }
13949                deserializer.deserialize_identifier(GeneratedVisitor)
13950            }
13951        }
13952        struct GeneratedVisitor;
13953        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13954            type Value = SetSessionParamResponse;
13955
13956            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13957                formatter.write_str("struct meta.SetSessionParamResponse")
13958            }
13959
13960            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSessionParamResponse, V::Error>
13961                where
13962                    V: serde::de::MapAccess<'de>,
13963            {
13964                let mut param__ = None;
13965                while let Some(k) = map_.next_key()? {
13966                    match k {
13967                        GeneratedField::Param => {
13968                            if param__.is_some() {
13969                                return Err(serde::de::Error::duplicate_field("param"));
13970                            }
13971                            param__ = Some(map_.next_value()?);
13972                        }
13973                    }
13974                }
13975                Ok(SetSessionParamResponse {
13976                    param: param__.unwrap_or_default(),
13977                })
13978            }
13979        }
13980        deserializer.deserialize_struct("meta.SetSessionParamResponse", FIELDS, GeneratedVisitor)
13981    }
13982}
13983impl serde::Serialize for SetSyncLogStoreAlignedRequest {
13984    #[allow(deprecated)]
13985    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13986    where
13987        S: serde::Serializer,
13988    {
13989        use serde::ser::SerializeStruct;
13990        let mut len = 0;
13991        if self.job_id != 0 {
13992            len += 1;
13993        }
13994        if self.aligned {
13995            len += 1;
13996        }
13997        let mut struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedRequest", len)?;
13998        if self.job_id != 0 {
13999            struct_ser.serialize_field("jobId", &self.job_id)?;
14000        }
14001        if self.aligned {
14002            struct_ser.serialize_field("aligned", &self.aligned)?;
14003        }
14004        struct_ser.end()
14005    }
14006}
14007impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedRequest {
14008    #[allow(deprecated)]
14009    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14010    where
14011        D: serde::Deserializer<'de>,
14012    {
14013        const FIELDS: &[&str] = &[
14014            "job_id",
14015            "jobId",
14016            "aligned",
14017        ];
14018
14019        #[allow(clippy::enum_variant_names)]
14020        enum GeneratedField {
14021            JobId,
14022            Aligned,
14023        }
14024        impl<'de> serde::Deserialize<'de> for GeneratedField {
14025            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14026            where
14027                D: serde::Deserializer<'de>,
14028            {
14029                struct GeneratedVisitor;
14030
14031                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14032                    type Value = GeneratedField;
14033
14034                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14035                        write!(formatter, "expected one of: {:?}", &FIELDS)
14036                    }
14037
14038                    #[allow(unused_variables)]
14039                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14040                    where
14041                        E: serde::de::Error,
14042                    {
14043                        match value {
14044                            "jobId" | "job_id" => Ok(GeneratedField::JobId),
14045                            "aligned" => Ok(GeneratedField::Aligned),
14046                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14047                        }
14048                    }
14049                }
14050                deserializer.deserialize_identifier(GeneratedVisitor)
14051            }
14052        }
14053        struct GeneratedVisitor;
14054        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14055            type Value = SetSyncLogStoreAlignedRequest;
14056
14057            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14058                formatter.write_str("struct meta.SetSyncLogStoreAlignedRequest")
14059            }
14060
14061            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedRequest, V::Error>
14062                where
14063                    V: serde::de::MapAccess<'de>,
14064            {
14065                let mut job_id__ = None;
14066                let mut aligned__ = None;
14067                while let Some(k) = map_.next_key()? {
14068                    match k {
14069                        GeneratedField::JobId => {
14070                            if job_id__.is_some() {
14071                                return Err(serde::de::Error::duplicate_field("jobId"));
14072                            }
14073                            job_id__ = 
14074                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14075                            ;
14076                        }
14077                        GeneratedField::Aligned => {
14078                            if aligned__.is_some() {
14079                                return Err(serde::de::Error::duplicate_field("aligned"));
14080                            }
14081                            aligned__ = Some(map_.next_value()?);
14082                        }
14083                    }
14084                }
14085                Ok(SetSyncLogStoreAlignedRequest {
14086                    job_id: job_id__.unwrap_or_default(),
14087                    aligned: aligned__.unwrap_or_default(),
14088                })
14089            }
14090        }
14091        deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedRequest", FIELDS, GeneratedVisitor)
14092    }
14093}
14094impl serde::Serialize for SetSyncLogStoreAlignedResponse {
14095    #[allow(deprecated)]
14096    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14097    where
14098        S: serde::Serializer,
14099    {
14100        use serde::ser::SerializeStruct;
14101        let len = 0;
14102        let struct_ser = serializer.serialize_struct("meta.SetSyncLogStoreAlignedResponse", len)?;
14103        struct_ser.end()
14104    }
14105}
14106impl<'de> serde::Deserialize<'de> for SetSyncLogStoreAlignedResponse {
14107    #[allow(deprecated)]
14108    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14109    where
14110        D: serde::Deserializer<'de>,
14111    {
14112        const FIELDS: &[&str] = &[
14113        ];
14114
14115        #[allow(clippy::enum_variant_names)]
14116        enum GeneratedField {
14117        }
14118        impl<'de> serde::Deserialize<'de> for GeneratedField {
14119            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14120            where
14121                D: serde::Deserializer<'de>,
14122            {
14123                struct GeneratedVisitor;
14124
14125                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14126                    type Value = GeneratedField;
14127
14128                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14129                        write!(formatter, "expected one of: {:?}", &FIELDS)
14130                    }
14131
14132                    #[allow(unused_variables)]
14133                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14134                    where
14135                        E: serde::de::Error,
14136                    {
14137                            Err(serde::de::Error::unknown_field(value, FIELDS))
14138                    }
14139                }
14140                deserializer.deserialize_identifier(GeneratedVisitor)
14141            }
14142        }
14143        struct GeneratedVisitor;
14144        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14145            type Value = SetSyncLogStoreAlignedResponse;
14146
14147            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14148                formatter.write_str("struct meta.SetSyncLogStoreAlignedResponse")
14149            }
14150
14151            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSyncLogStoreAlignedResponse, V::Error>
14152                where
14153                    V: serde::de::MapAccess<'de>,
14154            {
14155                while map_.next_key::<GeneratedField>()?.is_some() {
14156                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14157                }
14158                Ok(SetSyncLogStoreAlignedResponse {
14159                })
14160            }
14161        }
14162        deserializer.deserialize_struct("meta.SetSyncLogStoreAlignedResponse", FIELDS, GeneratedVisitor)
14163    }
14164}
14165impl serde::Serialize for SetSystemParamRequest {
14166    #[allow(deprecated)]
14167    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14168    where
14169        S: serde::Serializer,
14170    {
14171        use serde::ser::SerializeStruct;
14172        let mut len = 0;
14173        if !self.param.is_empty() {
14174            len += 1;
14175        }
14176        if self.value.is_some() {
14177            len += 1;
14178        }
14179        let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamRequest", len)?;
14180        if !self.param.is_empty() {
14181            struct_ser.serialize_field("param", &self.param)?;
14182        }
14183        if let Some(v) = self.value.as_ref() {
14184            struct_ser.serialize_field("value", v)?;
14185        }
14186        struct_ser.end()
14187    }
14188}
14189impl<'de> serde::Deserialize<'de> for SetSystemParamRequest {
14190    #[allow(deprecated)]
14191    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14192    where
14193        D: serde::Deserializer<'de>,
14194    {
14195        const FIELDS: &[&str] = &[
14196            "param",
14197            "value",
14198        ];
14199
14200        #[allow(clippy::enum_variant_names)]
14201        enum GeneratedField {
14202            Param,
14203            Value,
14204        }
14205        impl<'de> serde::Deserialize<'de> for GeneratedField {
14206            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14207            where
14208                D: serde::Deserializer<'de>,
14209            {
14210                struct GeneratedVisitor;
14211
14212                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14213                    type Value = GeneratedField;
14214
14215                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14216                        write!(formatter, "expected one of: {:?}", &FIELDS)
14217                    }
14218
14219                    #[allow(unused_variables)]
14220                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14221                    where
14222                        E: serde::de::Error,
14223                    {
14224                        match value {
14225                            "param" => Ok(GeneratedField::Param),
14226                            "value" => Ok(GeneratedField::Value),
14227                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14228                        }
14229                    }
14230                }
14231                deserializer.deserialize_identifier(GeneratedVisitor)
14232            }
14233        }
14234        struct GeneratedVisitor;
14235        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14236            type Value = SetSystemParamRequest;
14237
14238            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14239                formatter.write_str("struct meta.SetSystemParamRequest")
14240            }
14241
14242            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamRequest, V::Error>
14243                where
14244                    V: serde::de::MapAccess<'de>,
14245            {
14246                let mut param__ = None;
14247                let mut value__ = None;
14248                while let Some(k) = map_.next_key()? {
14249                    match k {
14250                        GeneratedField::Param => {
14251                            if param__.is_some() {
14252                                return Err(serde::de::Error::duplicate_field("param"));
14253                            }
14254                            param__ = Some(map_.next_value()?);
14255                        }
14256                        GeneratedField::Value => {
14257                            if value__.is_some() {
14258                                return Err(serde::de::Error::duplicate_field("value"));
14259                            }
14260                            value__ = map_.next_value()?;
14261                        }
14262                    }
14263                }
14264                Ok(SetSystemParamRequest {
14265                    param: param__.unwrap_or_default(),
14266                    value: value__,
14267                })
14268            }
14269        }
14270        deserializer.deserialize_struct("meta.SetSystemParamRequest", FIELDS, GeneratedVisitor)
14271    }
14272}
14273impl serde::Serialize for SetSystemParamResponse {
14274    #[allow(deprecated)]
14275    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14276    where
14277        S: serde::Serializer,
14278    {
14279        use serde::ser::SerializeStruct;
14280        let mut len = 0;
14281        if self.params.is_some() {
14282            len += 1;
14283        }
14284        let mut struct_ser = serializer.serialize_struct("meta.SetSystemParamResponse", len)?;
14285        if let Some(v) = self.params.as_ref() {
14286            struct_ser.serialize_field("params", v)?;
14287        }
14288        struct_ser.end()
14289    }
14290}
14291impl<'de> serde::Deserialize<'de> for SetSystemParamResponse {
14292    #[allow(deprecated)]
14293    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14294    where
14295        D: serde::Deserializer<'de>,
14296    {
14297        const FIELDS: &[&str] = &[
14298            "params",
14299        ];
14300
14301        #[allow(clippy::enum_variant_names)]
14302        enum GeneratedField {
14303            Params,
14304        }
14305        impl<'de> serde::Deserialize<'de> for GeneratedField {
14306            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14307            where
14308                D: serde::Deserializer<'de>,
14309            {
14310                struct GeneratedVisitor;
14311
14312                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14313                    type Value = GeneratedField;
14314
14315                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14316                        write!(formatter, "expected one of: {:?}", &FIELDS)
14317                    }
14318
14319                    #[allow(unused_variables)]
14320                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14321                    where
14322                        E: serde::de::Error,
14323                    {
14324                        match value {
14325                            "params" => Ok(GeneratedField::Params),
14326                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14327                        }
14328                    }
14329                }
14330                deserializer.deserialize_identifier(GeneratedVisitor)
14331            }
14332        }
14333        struct GeneratedVisitor;
14334        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14335            type Value = SetSystemParamResponse;
14336
14337            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14338                formatter.write_str("struct meta.SetSystemParamResponse")
14339            }
14340
14341            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SetSystemParamResponse, V::Error>
14342                where
14343                    V: serde::de::MapAccess<'de>,
14344            {
14345                let mut params__ = None;
14346                while let Some(k) = map_.next_key()? {
14347                    match k {
14348                        GeneratedField::Params => {
14349                            if params__.is_some() {
14350                                return Err(serde::de::Error::duplicate_field("params"));
14351                            }
14352                            params__ = map_.next_value()?;
14353                        }
14354                    }
14355                }
14356                Ok(SetSystemParamResponse {
14357                    params: params__,
14358                })
14359            }
14360        }
14361        deserializer.deserialize_struct("meta.SetSystemParamResponse", FIELDS, GeneratedVisitor)
14362    }
14363}
14364impl serde::Serialize for SubscribeRequest {
14365    #[allow(deprecated)]
14366    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14367    where
14368        S: serde::Serializer,
14369    {
14370        use serde::ser::SerializeStruct;
14371        let mut len = 0;
14372        if self.subscribe_type != 0 {
14373            len += 1;
14374        }
14375        if self.host.is_some() {
14376            len += 1;
14377        }
14378        if self.worker_id != 0 {
14379            len += 1;
14380        }
14381        let mut struct_ser = serializer.serialize_struct("meta.SubscribeRequest", len)?;
14382        if self.subscribe_type != 0 {
14383            let v = SubscribeType::try_from(self.subscribe_type)
14384                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.subscribe_type)))?;
14385            struct_ser.serialize_field("subscribeType", &v)?;
14386        }
14387        if let Some(v) = self.host.as_ref() {
14388            struct_ser.serialize_field("host", v)?;
14389        }
14390        if self.worker_id != 0 {
14391            struct_ser.serialize_field("workerId", &self.worker_id)?;
14392        }
14393        struct_ser.end()
14394    }
14395}
14396impl<'de> serde::Deserialize<'de> for SubscribeRequest {
14397    #[allow(deprecated)]
14398    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14399    where
14400        D: serde::Deserializer<'de>,
14401    {
14402        const FIELDS: &[&str] = &[
14403            "subscribe_type",
14404            "subscribeType",
14405            "host",
14406            "worker_id",
14407            "workerId",
14408        ];
14409
14410        #[allow(clippy::enum_variant_names)]
14411        enum GeneratedField {
14412            SubscribeType,
14413            Host,
14414            WorkerId,
14415        }
14416        impl<'de> serde::Deserialize<'de> for GeneratedField {
14417            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14418            where
14419                D: serde::Deserializer<'de>,
14420            {
14421                struct GeneratedVisitor;
14422
14423                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14424                    type Value = GeneratedField;
14425
14426                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14427                        write!(formatter, "expected one of: {:?}", &FIELDS)
14428                    }
14429
14430                    #[allow(unused_variables)]
14431                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14432                    where
14433                        E: serde::de::Error,
14434                    {
14435                        match value {
14436                            "subscribeType" | "subscribe_type" => Ok(GeneratedField::SubscribeType),
14437                            "host" => Ok(GeneratedField::Host),
14438                            "workerId" | "worker_id" => Ok(GeneratedField::WorkerId),
14439                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14440                        }
14441                    }
14442                }
14443                deserializer.deserialize_identifier(GeneratedVisitor)
14444            }
14445        }
14446        struct GeneratedVisitor;
14447        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14448            type Value = SubscribeRequest;
14449
14450            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14451                formatter.write_str("struct meta.SubscribeRequest")
14452            }
14453
14454            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeRequest, V::Error>
14455                where
14456                    V: serde::de::MapAccess<'de>,
14457            {
14458                let mut subscribe_type__ = None;
14459                let mut host__ = None;
14460                let mut worker_id__ = None;
14461                while let Some(k) = map_.next_key()? {
14462                    match k {
14463                        GeneratedField::SubscribeType => {
14464                            if subscribe_type__.is_some() {
14465                                return Err(serde::de::Error::duplicate_field("subscribeType"));
14466                            }
14467                            subscribe_type__ = Some(map_.next_value::<SubscribeType>()? as i32);
14468                        }
14469                        GeneratedField::Host => {
14470                            if host__.is_some() {
14471                                return Err(serde::de::Error::duplicate_field("host"));
14472                            }
14473                            host__ = map_.next_value()?;
14474                        }
14475                        GeneratedField::WorkerId => {
14476                            if worker_id__.is_some() {
14477                                return Err(serde::de::Error::duplicate_field("workerId"));
14478                            }
14479                            worker_id__ = 
14480                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14481                            ;
14482                        }
14483                    }
14484                }
14485                Ok(SubscribeRequest {
14486                    subscribe_type: subscribe_type__.unwrap_or_default(),
14487                    host: host__,
14488                    worker_id: worker_id__.unwrap_or_default(),
14489                })
14490            }
14491        }
14492        deserializer.deserialize_struct("meta.SubscribeRequest", FIELDS, GeneratedVisitor)
14493    }
14494}
14495impl serde::Serialize for SubscribeResponse {
14496    #[allow(deprecated)]
14497    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14498    where
14499        S: serde::Serializer,
14500    {
14501        use serde::ser::SerializeStruct;
14502        let mut len = 0;
14503        if self.status.is_some() {
14504            len += 1;
14505        }
14506        if self.operation != 0 {
14507            len += 1;
14508        }
14509        if self.version != 0 {
14510            len += 1;
14511        }
14512        if self.info.is_some() {
14513            len += 1;
14514        }
14515        let mut struct_ser = serializer.serialize_struct("meta.SubscribeResponse", len)?;
14516        if let Some(v) = self.status.as_ref() {
14517            struct_ser.serialize_field("status", v)?;
14518        }
14519        if self.operation != 0 {
14520            let v = subscribe_response::Operation::try_from(self.operation)
14521                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.operation)))?;
14522            struct_ser.serialize_field("operation", &v)?;
14523        }
14524        if self.version != 0 {
14525            #[allow(clippy::needless_borrow)]
14526            #[allow(clippy::needless_borrows_for_generic_args)]
14527            struct_ser.serialize_field("version", ToString::to_string(&self.version).as_str())?;
14528        }
14529        if let Some(v) = self.info.as_ref() {
14530            match v {
14531                subscribe_response::Info::Database(v) => {
14532                    struct_ser.serialize_field("database", v)?;
14533                }
14534                subscribe_response::Info::Schema(v) => {
14535                    struct_ser.serialize_field("schema", v)?;
14536                }
14537                subscribe_response::Info::Function(v) => {
14538                    struct_ser.serialize_field("function", v)?;
14539                }
14540                subscribe_response::Info::User(v) => {
14541                    struct_ser.serialize_field("user", v)?;
14542                }
14543                subscribe_response::Info::SessionParam(v) => {
14544                    struct_ser.serialize_field("sessionParam", v)?;
14545                }
14546                subscribe_response::Info::Node(v) => {
14547                    struct_ser.serialize_field("node", v)?;
14548                }
14549                subscribe_response::Info::HummockVersionDeltas(v) => {
14550                    struct_ser.serialize_field("hummockVersionDeltas", v)?;
14551                }
14552                subscribe_response::Info::Snapshot(v) => {
14553                    struct_ser.serialize_field("snapshot", v)?;
14554                }
14555                subscribe_response::Info::MetaBackupManifestId(v) => {
14556                    struct_ser.serialize_field("metaBackupManifestId", v)?;
14557                }
14558                subscribe_response::Info::SystemParams(v) => {
14559                    struct_ser.serialize_field("systemParams", v)?;
14560                }
14561                subscribe_response::Info::HummockWriteLimits(v) => {
14562                    struct_ser.serialize_field("hummockWriteLimits", v)?;
14563                }
14564                subscribe_response::Info::ObjectGroup(v) => {
14565                    struct_ser.serialize_field("objectGroup", v)?;
14566                }
14567                subscribe_response::Info::Connection(v) => {
14568                    struct_ser.serialize_field("connection", v)?;
14569                }
14570                subscribe_response::Info::HummockStats(v) => {
14571                    struct_ser.serialize_field("hummockStats", v)?;
14572                }
14573                subscribe_response::Info::Recovery(v) => {
14574                    struct_ser.serialize_field("recovery", v)?;
14575                }
14576                subscribe_response::Info::StreamingWorkerSlotMapping(v) => {
14577                    struct_ser.serialize_field("streamingWorkerSlotMapping", v)?;
14578                }
14579                subscribe_response::Info::ServingWorkerSlotMappings(v) => {
14580                    struct_ser.serialize_field("servingWorkerSlotMappings", v)?;
14581                }
14582                subscribe_response::Info::Secret(v) => {
14583                    struct_ser.serialize_field("secret", v)?;
14584                }
14585                subscribe_response::Info::ComputeNodeTotalCpuCount(v) => {
14586                    #[allow(clippy::needless_borrow)]
14587                    #[allow(clippy::needless_borrows_for_generic_args)]
14588                    struct_ser.serialize_field("computeNodeTotalCpuCount", ToString::to_string(&v).as_str())?;
14589                }
14590            }
14591        }
14592        struct_ser.end()
14593    }
14594}
14595impl<'de> serde::Deserialize<'de> for SubscribeResponse {
14596    #[allow(deprecated)]
14597    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14598    where
14599        D: serde::Deserializer<'de>,
14600    {
14601        const FIELDS: &[&str] = &[
14602            "status",
14603            "operation",
14604            "version",
14605            "database",
14606            "schema",
14607            "function",
14608            "user",
14609            "session_param",
14610            "sessionParam",
14611            "node",
14612            "hummock_version_deltas",
14613            "hummockVersionDeltas",
14614            "snapshot",
14615            "meta_backup_manifest_id",
14616            "metaBackupManifestId",
14617            "system_params",
14618            "systemParams",
14619            "hummock_write_limits",
14620            "hummockWriteLimits",
14621            "object_group",
14622            "objectGroup",
14623            "connection",
14624            "hummock_stats",
14625            "hummockStats",
14626            "recovery",
14627            "streaming_worker_slot_mapping",
14628            "streamingWorkerSlotMapping",
14629            "serving_worker_slot_mappings",
14630            "servingWorkerSlotMappings",
14631            "secret",
14632            "compute_node_total_cpu_count",
14633            "computeNodeTotalCpuCount",
14634        ];
14635
14636        #[allow(clippy::enum_variant_names)]
14637        enum GeneratedField {
14638            Status,
14639            Operation,
14640            Version,
14641            Database,
14642            Schema,
14643            Function,
14644            User,
14645            SessionParam,
14646            Node,
14647            HummockVersionDeltas,
14648            Snapshot,
14649            MetaBackupManifestId,
14650            SystemParams,
14651            HummockWriteLimits,
14652            ObjectGroup,
14653            Connection,
14654            HummockStats,
14655            Recovery,
14656            StreamingWorkerSlotMapping,
14657            ServingWorkerSlotMappings,
14658            Secret,
14659            ComputeNodeTotalCpuCount,
14660        }
14661        impl<'de> serde::Deserialize<'de> for GeneratedField {
14662            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14663            where
14664                D: serde::Deserializer<'de>,
14665            {
14666                struct GeneratedVisitor;
14667
14668                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14669                    type Value = GeneratedField;
14670
14671                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14672                        write!(formatter, "expected one of: {:?}", &FIELDS)
14673                    }
14674
14675                    #[allow(unused_variables)]
14676                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14677                    where
14678                        E: serde::de::Error,
14679                    {
14680                        match value {
14681                            "status" => Ok(GeneratedField::Status),
14682                            "operation" => Ok(GeneratedField::Operation),
14683                            "version" => Ok(GeneratedField::Version),
14684                            "database" => Ok(GeneratedField::Database),
14685                            "schema" => Ok(GeneratedField::Schema),
14686                            "function" => Ok(GeneratedField::Function),
14687                            "user" => Ok(GeneratedField::User),
14688                            "sessionParam" | "session_param" => Ok(GeneratedField::SessionParam),
14689                            "node" => Ok(GeneratedField::Node),
14690                            "hummockVersionDeltas" | "hummock_version_deltas" => Ok(GeneratedField::HummockVersionDeltas),
14691                            "snapshot" => Ok(GeneratedField::Snapshot),
14692                            "metaBackupManifestId" | "meta_backup_manifest_id" => Ok(GeneratedField::MetaBackupManifestId),
14693                            "systemParams" | "system_params" => Ok(GeneratedField::SystemParams),
14694                            "hummockWriteLimits" | "hummock_write_limits" => Ok(GeneratedField::HummockWriteLimits),
14695                            "objectGroup" | "object_group" => Ok(GeneratedField::ObjectGroup),
14696                            "connection" => Ok(GeneratedField::Connection),
14697                            "hummockStats" | "hummock_stats" => Ok(GeneratedField::HummockStats),
14698                            "recovery" => Ok(GeneratedField::Recovery),
14699                            "streamingWorkerSlotMapping" | "streaming_worker_slot_mapping" => Ok(GeneratedField::StreamingWorkerSlotMapping),
14700                            "servingWorkerSlotMappings" | "serving_worker_slot_mappings" => Ok(GeneratedField::ServingWorkerSlotMappings),
14701                            "secret" => Ok(GeneratedField::Secret),
14702                            "computeNodeTotalCpuCount" | "compute_node_total_cpu_count" => Ok(GeneratedField::ComputeNodeTotalCpuCount),
14703                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14704                        }
14705                    }
14706                }
14707                deserializer.deserialize_identifier(GeneratedVisitor)
14708            }
14709        }
14710        struct GeneratedVisitor;
14711        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14712            type Value = SubscribeResponse;
14713
14714            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14715                formatter.write_str("struct meta.SubscribeResponse")
14716            }
14717
14718            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscribeResponse, V::Error>
14719                where
14720                    V: serde::de::MapAccess<'de>,
14721            {
14722                let mut status__ = None;
14723                let mut operation__ = None;
14724                let mut version__ = None;
14725                let mut info__ = None;
14726                while let Some(k) = map_.next_key()? {
14727                    match k {
14728                        GeneratedField::Status => {
14729                            if status__.is_some() {
14730                                return Err(serde::de::Error::duplicate_field("status"));
14731                            }
14732                            status__ = map_.next_value()?;
14733                        }
14734                        GeneratedField::Operation => {
14735                            if operation__.is_some() {
14736                                return Err(serde::de::Error::duplicate_field("operation"));
14737                            }
14738                            operation__ = Some(map_.next_value::<subscribe_response::Operation>()? as i32);
14739                        }
14740                        GeneratedField::Version => {
14741                            if version__.is_some() {
14742                                return Err(serde::de::Error::duplicate_field("version"));
14743                            }
14744                            version__ = 
14745                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14746                            ;
14747                        }
14748                        GeneratedField::Database => {
14749                            if info__.is_some() {
14750                                return Err(serde::de::Error::duplicate_field("database"));
14751                            }
14752                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Database)
14753;
14754                        }
14755                        GeneratedField::Schema => {
14756                            if info__.is_some() {
14757                                return Err(serde::de::Error::duplicate_field("schema"));
14758                            }
14759                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Schema)
14760;
14761                        }
14762                        GeneratedField::Function => {
14763                            if info__.is_some() {
14764                                return Err(serde::de::Error::duplicate_field("function"));
14765                            }
14766                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Function)
14767;
14768                        }
14769                        GeneratedField::User => {
14770                            if info__.is_some() {
14771                                return Err(serde::de::Error::duplicate_field("user"));
14772                            }
14773                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::User)
14774;
14775                        }
14776                        GeneratedField::SessionParam => {
14777                            if info__.is_some() {
14778                                return Err(serde::de::Error::duplicate_field("sessionParam"));
14779                            }
14780                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SessionParam)
14781;
14782                        }
14783                        GeneratedField::Node => {
14784                            if info__.is_some() {
14785                                return Err(serde::de::Error::duplicate_field("node"));
14786                            }
14787                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Node)
14788;
14789                        }
14790                        GeneratedField::HummockVersionDeltas => {
14791                            if info__.is_some() {
14792                                return Err(serde::de::Error::duplicate_field("hummockVersionDeltas"));
14793                            }
14794                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockVersionDeltas)
14795;
14796                        }
14797                        GeneratedField::Snapshot => {
14798                            if info__.is_some() {
14799                                return Err(serde::de::Error::duplicate_field("snapshot"));
14800                            }
14801                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Snapshot)
14802;
14803                        }
14804                        GeneratedField::MetaBackupManifestId => {
14805                            if info__.is_some() {
14806                                return Err(serde::de::Error::duplicate_field("metaBackupManifestId"));
14807                            }
14808                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::MetaBackupManifestId)
14809;
14810                        }
14811                        GeneratedField::SystemParams => {
14812                            if info__.is_some() {
14813                                return Err(serde::de::Error::duplicate_field("systemParams"));
14814                            }
14815                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::SystemParams)
14816;
14817                        }
14818                        GeneratedField::HummockWriteLimits => {
14819                            if info__.is_some() {
14820                                return Err(serde::de::Error::duplicate_field("hummockWriteLimits"));
14821                            }
14822                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockWriteLimits)
14823;
14824                        }
14825                        GeneratedField::ObjectGroup => {
14826                            if info__.is_some() {
14827                                return Err(serde::de::Error::duplicate_field("objectGroup"));
14828                            }
14829                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ObjectGroup)
14830;
14831                        }
14832                        GeneratedField::Connection => {
14833                            if info__.is_some() {
14834                                return Err(serde::de::Error::duplicate_field("connection"));
14835                            }
14836                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Connection)
14837;
14838                        }
14839                        GeneratedField::HummockStats => {
14840                            if info__.is_some() {
14841                                return Err(serde::de::Error::duplicate_field("hummockStats"));
14842                            }
14843                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::HummockStats)
14844;
14845                        }
14846                        GeneratedField::Recovery => {
14847                            if info__.is_some() {
14848                                return Err(serde::de::Error::duplicate_field("recovery"));
14849                            }
14850                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Recovery)
14851;
14852                        }
14853                        GeneratedField::StreamingWorkerSlotMapping => {
14854                            if info__.is_some() {
14855                                return Err(serde::de::Error::duplicate_field("streamingWorkerSlotMapping"));
14856                            }
14857                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::StreamingWorkerSlotMapping)
14858;
14859                        }
14860                        GeneratedField::ServingWorkerSlotMappings => {
14861                            if info__.is_some() {
14862                                return Err(serde::de::Error::duplicate_field("servingWorkerSlotMappings"));
14863                            }
14864                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::ServingWorkerSlotMappings)
14865;
14866                        }
14867                        GeneratedField::Secret => {
14868                            if info__.is_some() {
14869                                return Err(serde::de::Error::duplicate_field("secret"));
14870                            }
14871                            info__ = map_.next_value::<::std::option::Option<_>>()?.map(subscribe_response::Info::Secret)
14872;
14873                        }
14874                        GeneratedField::ComputeNodeTotalCpuCount => {
14875                            if info__.is_some() {
14876                                return Err(serde::de::Error::duplicate_field("computeNodeTotalCpuCount"));
14877                            }
14878                            info__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| subscribe_response::Info::ComputeNodeTotalCpuCount(x.0));
14879                        }
14880                    }
14881                }
14882                Ok(SubscribeResponse {
14883                    status: status__,
14884                    operation: operation__.unwrap_or_default(),
14885                    version: version__.unwrap_or_default(),
14886                    info: info__,
14887                })
14888            }
14889        }
14890        deserializer.deserialize_struct("meta.SubscribeResponse", FIELDS, GeneratedVisitor)
14891    }
14892}
14893impl serde::Serialize for subscribe_response::Operation {
14894    #[allow(deprecated)]
14895    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14896    where
14897        S: serde::Serializer,
14898    {
14899        let variant = match self {
14900            Self::Unspecified => "UNSPECIFIED",
14901            Self::Add => "ADD",
14902            Self::Delete => "DELETE",
14903            Self::Update => "UPDATE",
14904            Self::Snapshot => "SNAPSHOT",
14905        };
14906        serializer.serialize_str(variant)
14907    }
14908}
14909impl<'de> serde::Deserialize<'de> for subscribe_response::Operation {
14910    #[allow(deprecated)]
14911    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14912    where
14913        D: serde::Deserializer<'de>,
14914    {
14915        const FIELDS: &[&str] = &[
14916            "UNSPECIFIED",
14917            "ADD",
14918            "DELETE",
14919            "UPDATE",
14920            "SNAPSHOT",
14921        ];
14922
14923        struct GeneratedVisitor;
14924
14925        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14926            type Value = subscribe_response::Operation;
14927
14928            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14929                write!(formatter, "expected one of: {:?}", &FIELDS)
14930            }
14931
14932            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
14933            where
14934                E: serde::de::Error,
14935            {
14936                i32::try_from(v)
14937                    .ok()
14938                    .and_then(|x| x.try_into().ok())
14939                    .ok_or_else(|| {
14940                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
14941                    })
14942            }
14943
14944            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
14945            where
14946                E: serde::de::Error,
14947            {
14948                i32::try_from(v)
14949                    .ok()
14950                    .and_then(|x| x.try_into().ok())
14951                    .ok_or_else(|| {
14952                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
14953                    })
14954            }
14955
14956            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
14957            where
14958                E: serde::de::Error,
14959            {
14960                match value {
14961                    "UNSPECIFIED" => Ok(subscribe_response::Operation::Unspecified),
14962                    "ADD" => Ok(subscribe_response::Operation::Add),
14963                    "DELETE" => Ok(subscribe_response::Operation::Delete),
14964                    "UPDATE" => Ok(subscribe_response::Operation::Update),
14965                    "SNAPSHOT" => Ok(subscribe_response::Operation::Snapshot),
14966                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
14967                }
14968            }
14969        }
14970        deserializer.deserialize_any(GeneratedVisitor)
14971    }
14972}
14973impl serde::Serialize for SubscribeType {
14974    #[allow(deprecated)]
14975    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14976    where
14977        S: serde::Serializer,
14978    {
14979        let variant = match self {
14980            Self::Unspecified => "UNSPECIFIED",
14981            Self::Frontend => "FRONTEND",
14982            Self::Hummock => "HUMMOCK",
14983            Self::Compactor => "COMPACTOR",
14984            Self::Compute => "COMPUTE",
14985        };
14986        serializer.serialize_str(variant)
14987    }
14988}
14989impl<'de> serde::Deserialize<'de> for SubscribeType {
14990    #[allow(deprecated)]
14991    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14992    where
14993        D: serde::Deserializer<'de>,
14994    {
14995        const FIELDS: &[&str] = &[
14996            "UNSPECIFIED",
14997            "FRONTEND",
14998            "HUMMOCK",
14999            "COMPACTOR",
15000            "COMPUTE",
15001        ];
15002
15003        struct GeneratedVisitor;
15004
15005        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15006            type Value = SubscribeType;
15007
15008            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15009                write!(formatter, "expected one of: {:?}", &FIELDS)
15010            }
15011
15012            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15013            where
15014                E: serde::de::Error,
15015            {
15016                i32::try_from(v)
15017                    .ok()
15018                    .and_then(|x| x.try_into().ok())
15019                    .ok_or_else(|| {
15020                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15021                    })
15022            }
15023
15024            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15025            where
15026                E: serde::de::Error,
15027            {
15028                i32::try_from(v)
15029                    .ok()
15030                    .and_then(|x| x.try_into().ok())
15031                    .ok_or_else(|| {
15032                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15033                    })
15034            }
15035
15036            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15037            where
15038                E: serde::de::Error,
15039            {
15040                match value {
15041                    "UNSPECIFIED" => Ok(SubscribeType::Unspecified),
15042                    "FRONTEND" => Ok(SubscribeType::Frontend),
15043                    "HUMMOCK" => Ok(SubscribeType::Hummock),
15044                    "COMPACTOR" => Ok(SubscribeType::Compactor),
15045                    "COMPUTE" => Ok(SubscribeType::Compute),
15046                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15047                }
15048            }
15049        }
15050        deserializer.deserialize_any(GeneratedVisitor)
15051    }
15052}
15053impl serde::Serialize for SystemParams {
15054    #[allow(deprecated)]
15055    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15056    where
15057        S: serde::Serializer,
15058    {
15059        use serde::ser::SerializeStruct;
15060        let mut len = 0;
15061        if self.barrier_interval_ms.is_some() {
15062            len += 1;
15063        }
15064        if self.checkpoint_frequency.is_some() {
15065            len += 1;
15066        }
15067        if self.sstable_size_mb.is_some() {
15068            len += 1;
15069        }
15070        if self.block_size_kb.is_some() {
15071            len += 1;
15072        }
15073        if self.bloom_false_positive.is_some() {
15074            len += 1;
15075        }
15076        if self.state_store.is_some() {
15077            len += 1;
15078        }
15079        if self.data_directory.is_some() {
15080            len += 1;
15081        }
15082        if self.backup_storage_url.is_some() {
15083            len += 1;
15084        }
15085        if self.backup_storage_directory.is_some() {
15086            len += 1;
15087        }
15088        if self.telemetry_enabled.is_some() {
15089            len += 1;
15090        }
15091        if self.parallel_compact_size_mb.is_some() {
15092            len += 1;
15093        }
15094        if self.max_concurrent_creating_streaming_jobs.is_some() {
15095            len += 1;
15096        }
15097        if self.pause_on_next_bootstrap.is_some() {
15098            len += 1;
15099        }
15100        if self.wasm_storage_url.is_some() {
15101            len += 1;
15102        }
15103        if self.enable_tracing.is_some() {
15104            len += 1;
15105        }
15106        if self.use_new_object_prefix_strategy.is_some() {
15107            len += 1;
15108        }
15109        if self.license_key.is_some() {
15110            len += 1;
15111        }
15112        if self.time_travel_retention_ms.is_some() {
15113            len += 1;
15114        }
15115        if self.adaptive_parallelism_strategy.is_some() {
15116            len += 1;
15117        }
15118        if self.per_database_isolation.is_some() {
15119            len += 1;
15120        }
15121        if self.enforce_secret.is_some() {
15122            len += 1;
15123        }
15124        let mut struct_ser = serializer.serialize_struct("meta.SystemParams", len)?;
15125        if let Some(v) = self.barrier_interval_ms.as_ref() {
15126            struct_ser.serialize_field("barrierIntervalMs", v)?;
15127        }
15128        if let Some(v) = self.checkpoint_frequency.as_ref() {
15129            #[allow(clippy::needless_borrow)]
15130            #[allow(clippy::needless_borrows_for_generic_args)]
15131            struct_ser.serialize_field("checkpointFrequency", ToString::to_string(&v).as_str())?;
15132        }
15133        if let Some(v) = self.sstable_size_mb.as_ref() {
15134            struct_ser.serialize_field("sstableSizeMb", v)?;
15135        }
15136        if let Some(v) = self.block_size_kb.as_ref() {
15137            struct_ser.serialize_field("blockSizeKb", v)?;
15138        }
15139        if let Some(v) = self.bloom_false_positive.as_ref() {
15140            struct_ser.serialize_field("bloomFalsePositive", v)?;
15141        }
15142        if let Some(v) = self.state_store.as_ref() {
15143            struct_ser.serialize_field("stateStore", v)?;
15144        }
15145        if let Some(v) = self.data_directory.as_ref() {
15146            struct_ser.serialize_field("dataDirectory", v)?;
15147        }
15148        if let Some(v) = self.backup_storage_url.as_ref() {
15149            struct_ser.serialize_field("backupStorageUrl", v)?;
15150        }
15151        if let Some(v) = self.backup_storage_directory.as_ref() {
15152            struct_ser.serialize_field("backupStorageDirectory", v)?;
15153        }
15154        if let Some(v) = self.telemetry_enabled.as_ref() {
15155            struct_ser.serialize_field("telemetryEnabled", v)?;
15156        }
15157        if let Some(v) = self.parallel_compact_size_mb.as_ref() {
15158            struct_ser.serialize_field("parallelCompactSizeMb", v)?;
15159        }
15160        if let Some(v) = self.max_concurrent_creating_streaming_jobs.as_ref() {
15161            struct_ser.serialize_field("maxConcurrentCreatingStreamingJobs", v)?;
15162        }
15163        if let Some(v) = self.pause_on_next_bootstrap.as_ref() {
15164            struct_ser.serialize_field("pauseOnNextBootstrap", v)?;
15165        }
15166        if let Some(v) = self.wasm_storage_url.as_ref() {
15167            struct_ser.serialize_field("wasmStorageUrl", v)?;
15168        }
15169        if let Some(v) = self.enable_tracing.as_ref() {
15170            struct_ser.serialize_field("enableTracing", v)?;
15171        }
15172        if let Some(v) = self.use_new_object_prefix_strategy.as_ref() {
15173            struct_ser.serialize_field("useNewObjectPrefixStrategy", v)?;
15174        }
15175        if let Some(v) = self.license_key.as_ref() {
15176            struct_ser.serialize_field("licenseKey", v)?;
15177        }
15178        if let Some(v) = self.time_travel_retention_ms.as_ref() {
15179            #[allow(clippy::needless_borrow)]
15180            #[allow(clippy::needless_borrows_for_generic_args)]
15181            struct_ser.serialize_field("timeTravelRetentionMs", ToString::to_string(&v).as_str())?;
15182        }
15183        if let Some(v) = self.adaptive_parallelism_strategy.as_ref() {
15184            struct_ser.serialize_field("adaptiveParallelismStrategy", v)?;
15185        }
15186        if let Some(v) = self.per_database_isolation.as_ref() {
15187            struct_ser.serialize_field("perDatabaseIsolation", v)?;
15188        }
15189        if let Some(v) = self.enforce_secret.as_ref() {
15190            struct_ser.serialize_field("enforceSecret", v)?;
15191        }
15192        struct_ser.end()
15193    }
15194}
15195impl<'de> serde::Deserialize<'de> for SystemParams {
15196    #[allow(deprecated)]
15197    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15198    where
15199        D: serde::Deserializer<'de>,
15200    {
15201        const FIELDS: &[&str] = &[
15202            "barrier_interval_ms",
15203            "barrierIntervalMs",
15204            "checkpoint_frequency",
15205            "checkpointFrequency",
15206            "sstable_size_mb",
15207            "sstableSizeMb",
15208            "block_size_kb",
15209            "blockSizeKb",
15210            "bloom_false_positive",
15211            "bloomFalsePositive",
15212            "state_store",
15213            "stateStore",
15214            "data_directory",
15215            "dataDirectory",
15216            "backup_storage_url",
15217            "backupStorageUrl",
15218            "backup_storage_directory",
15219            "backupStorageDirectory",
15220            "telemetry_enabled",
15221            "telemetryEnabled",
15222            "parallel_compact_size_mb",
15223            "parallelCompactSizeMb",
15224            "max_concurrent_creating_streaming_jobs",
15225            "maxConcurrentCreatingStreamingJobs",
15226            "pause_on_next_bootstrap",
15227            "pauseOnNextBootstrap",
15228            "wasm_storage_url",
15229            "wasmStorageUrl",
15230            "enable_tracing",
15231            "enableTracing",
15232            "use_new_object_prefix_strategy",
15233            "useNewObjectPrefixStrategy",
15234            "license_key",
15235            "licenseKey",
15236            "time_travel_retention_ms",
15237            "timeTravelRetentionMs",
15238            "adaptive_parallelism_strategy",
15239            "adaptiveParallelismStrategy",
15240            "per_database_isolation",
15241            "perDatabaseIsolation",
15242            "enforce_secret",
15243            "enforceSecret",
15244        ];
15245
15246        #[allow(clippy::enum_variant_names)]
15247        enum GeneratedField {
15248            BarrierIntervalMs,
15249            CheckpointFrequency,
15250            SstableSizeMb,
15251            BlockSizeKb,
15252            BloomFalsePositive,
15253            StateStore,
15254            DataDirectory,
15255            BackupStorageUrl,
15256            BackupStorageDirectory,
15257            TelemetryEnabled,
15258            ParallelCompactSizeMb,
15259            MaxConcurrentCreatingStreamingJobs,
15260            PauseOnNextBootstrap,
15261            WasmStorageUrl,
15262            EnableTracing,
15263            UseNewObjectPrefixStrategy,
15264            LicenseKey,
15265            TimeTravelRetentionMs,
15266            AdaptiveParallelismStrategy,
15267            PerDatabaseIsolation,
15268            EnforceSecret,
15269        }
15270        impl<'de> serde::Deserialize<'de> for GeneratedField {
15271            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15272            where
15273                D: serde::Deserializer<'de>,
15274            {
15275                struct GeneratedVisitor;
15276
15277                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15278                    type Value = GeneratedField;
15279
15280                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15281                        write!(formatter, "expected one of: {:?}", &FIELDS)
15282                    }
15283
15284                    #[allow(unused_variables)]
15285                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15286                    where
15287                        E: serde::de::Error,
15288                    {
15289                        match value {
15290                            "barrierIntervalMs" | "barrier_interval_ms" => Ok(GeneratedField::BarrierIntervalMs),
15291                            "checkpointFrequency" | "checkpoint_frequency" => Ok(GeneratedField::CheckpointFrequency),
15292                            "sstableSizeMb" | "sstable_size_mb" => Ok(GeneratedField::SstableSizeMb),
15293                            "blockSizeKb" | "block_size_kb" => Ok(GeneratedField::BlockSizeKb),
15294                            "bloomFalsePositive" | "bloom_false_positive" => Ok(GeneratedField::BloomFalsePositive),
15295                            "stateStore" | "state_store" => Ok(GeneratedField::StateStore),
15296                            "dataDirectory" | "data_directory" => Ok(GeneratedField::DataDirectory),
15297                            "backupStorageUrl" | "backup_storage_url" => Ok(GeneratedField::BackupStorageUrl),
15298                            "backupStorageDirectory" | "backup_storage_directory" => Ok(GeneratedField::BackupStorageDirectory),
15299                            "telemetryEnabled" | "telemetry_enabled" => Ok(GeneratedField::TelemetryEnabled),
15300                            "parallelCompactSizeMb" | "parallel_compact_size_mb" => Ok(GeneratedField::ParallelCompactSizeMb),
15301                            "maxConcurrentCreatingStreamingJobs" | "max_concurrent_creating_streaming_jobs" => Ok(GeneratedField::MaxConcurrentCreatingStreamingJobs),
15302                            "pauseOnNextBootstrap" | "pause_on_next_bootstrap" => Ok(GeneratedField::PauseOnNextBootstrap),
15303                            "wasmStorageUrl" | "wasm_storage_url" => Ok(GeneratedField::WasmStorageUrl),
15304                            "enableTracing" | "enable_tracing" => Ok(GeneratedField::EnableTracing),
15305                            "useNewObjectPrefixStrategy" | "use_new_object_prefix_strategy" => Ok(GeneratedField::UseNewObjectPrefixStrategy),
15306                            "licenseKey" | "license_key" => Ok(GeneratedField::LicenseKey),
15307                            "timeTravelRetentionMs" | "time_travel_retention_ms" => Ok(GeneratedField::TimeTravelRetentionMs),
15308                            "adaptiveParallelismStrategy" | "adaptive_parallelism_strategy" => Ok(GeneratedField::AdaptiveParallelismStrategy),
15309                            "perDatabaseIsolation" | "per_database_isolation" => Ok(GeneratedField::PerDatabaseIsolation),
15310                            "enforceSecret" | "enforce_secret" => Ok(GeneratedField::EnforceSecret),
15311                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15312                        }
15313                    }
15314                }
15315                deserializer.deserialize_identifier(GeneratedVisitor)
15316            }
15317        }
15318        struct GeneratedVisitor;
15319        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15320            type Value = SystemParams;
15321
15322            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15323                formatter.write_str("struct meta.SystemParams")
15324            }
15325
15326            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SystemParams, V::Error>
15327                where
15328                    V: serde::de::MapAccess<'de>,
15329            {
15330                let mut barrier_interval_ms__ = None;
15331                let mut checkpoint_frequency__ = None;
15332                let mut sstable_size_mb__ = None;
15333                let mut block_size_kb__ = None;
15334                let mut bloom_false_positive__ = None;
15335                let mut state_store__ = None;
15336                let mut data_directory__ = None;
15337                let mut backup_storage_url__ = None;
15338                let mut backup_storage_directory__ = None;
15339                let mut telemetry_enabled__ = None;
15340                let mut parallel_compact_size_mb__ = None;
15341                let mut max_concurrent_creating_streaming_jobs__ = None;
15342                let mut pause_on_next_bootstrap__ = None;
15343                let mut wasm_storage_url__ = None;
15344                let mut enable_tracing__ = None;
15345                let mut use_new_object_prefix_strategy__ = None;
15346                let mut license_key__ = None;
15347                let mut time_travel_retention_ms__ = None;
15348                let mut adaptive_parallelism_strategy__ = None;
15349                let mut per_database_isolation__ = None;
15350                let mut enforce_secret__ = None;
15351                while let Some(k) = map_.next_key()? {
15352                    match k {
15353                        GeneratedField::BarrierIntervalMs => {
15354                            if barrier_interval_ms__.is_some() {
15355                                return Err(serde::de::Error::duplicate_field("barrierIntervalMs"));
15356                            }
15357                            barrier_interval_ms__ = 
15358                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15359                            ;
15360                        }
15361                        GeneratedField::CheckpointFrequency => {
15362                            if checkpoint_frequency__.is_some() {
15363                                return Err(serde::de::Error::duplicate_field("checkpointFrequency"));
15364                            }
15365                            checkpoint_frequency__ = 
15366                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15367                            ;
15368                        }
15369                        GeneratedField::SstableSizeMb => {
15370                            if sstable_size_mb__.is_some() {
15371                                return Err(serde::de::Error::duplicate_field("sstableSizeMb"));
15372                            }
15373                            sstable_size_mb__ = 
15374                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15375                            ;
15376                        }
15377                        GeneratedField::BlockSizeKb => {
15378                            if block_size_kb__.is_some() {
15379                                return Err(serde::de::Error::duplicate_field("blockSizeKb"));
15380                            }
15381                            block_size_kb__ = 
15382                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15383                            ;
15384                        }
15385                        GeneratedField::BloomFalsePositive => {
15386                            if bloom_false_positive__.is_some() {
15387                                return Err(serde::de::Error::duplicate_field("bloomFalsePositive"));
15388                            }
15389                            bloom_false_positive__ = 
15390                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15391                            ;
15392                        }
15393                        GeneratedField::StateStore => {
15394                            if state_store__.is_some() {
15395                                return Err(serde::de::Error::duplicate_field("stateStore"));
15396                            }
15397                            state_store__ = map_.next_value()?;
15398                        }
15399                        GeneratedField::DataDirectory => {
15400                            if data_directory__.is_some() {
15401                                return Err(serde::de::Error::duplicate_field("dataDirectory"));
15402                            }
15403                            data_directory__ = map_.next_value()?;
15404                        }
15405                        GeneratedField::BackupStorageUrl => {
15406                            if backup_storage_url__.is_some() {
15407                                return Err(serde::de::Error::duplicate_field("backupStorageUrl"));
15408                            }
15409                            backup_storage_url__ = map_.next_value()?;
15410                        }
15411                        GeneratedField::BackupStorageDirectory => {
15412                            if backup_storage_directory__.is_some() {
15413                                return Err(serde::de::Error::duplicate_field("backupStorageDirectory"));
15414                            }
15415                            backup_storage_directory__ = map_.next_value()?;
15416                        }
15417                        GeneratedField::TelemetryEnabled => {
15418                            if telemetry_enabled__.is_some() {
15419                                return Err(serde::de::Error::duplicate_field("telemetryEnabled"));
15420                            }
15421                            telemetry_enabled__ = map_.next_value()?;
15422                        }
15423                        GeneratedField::ParallelCompactSizeMb => {
15424                            if parallel_compact_size_mb__.is_some() {
15425                                return Err(serde::de::Error::duplicate_field("parallelCompactSizeMb"));
15426                            }
15427                            parallel_compact_size_mb__ = 
15428                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15429                            ;
15430                        }
15431                        GeneratedField::MaxConcurrentCreatingStreamingJobs => {
15432                            if max_concurrent_creating_streaming_jobs__.is_some() {
15433                                return Err(serde::de::Error::duplicate_field("maxConcurrentCreatingStreamingJobs"));
15434                            }
15435                            max_concurrent_creating_streaming_jobs__ = 
15436                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15437                            ;
15438                        }
15439                        GeneratedField::PauseOnNextBootstrap => {
15440                            if pause_on_next_bootstrap__.is_some() {
15441                                return Err(serde::de::Error::duplicate_field("pauseOnNextBootstrap"));
15442                            }
15443                            pause_on_next_bootstrap__ = map_.next_value()?;
15444                        }
15445                        GeneratedField::WasmStorageUrl => {
15446                            if wasm_storage_url__.is_some() {
15447                                return Err(serde::de::Error::duplicate_field("wasmStorageUrl"));
15448                            }
15449                            wasm_storage_url__ = map_.next_value()?;
15450                        }
15451                        GeneratedField::EnableTracing => {
15452                            if enable_tracing__.is_some() {
15453                                return Err(serde::de::Error::duplicate_field("enableTracing"));
15454                            }
15455                            enable_tracing__ = map_.next_value()?;
15456                        }
15457                        GeneratedField::UseNewObjectPrefixStrategy => {
15458                            if use_new_object_prefix_strategy__.is_some() {
15459                                return Err(serde::de::Error::duplicate_field("useNewObjectPrefixStrategy"));
15460                            }
15461                            use_new_object_prefix_strategy__ = map_.next_value()?;
15462                        }
15463                        GeneratedField::LicenseKey => {
15464                            if license_key__.is_some() {
15465                                return Err(serde::de::Error::duplicate_field("licenseKey"));
15466                            }
15467                            license_key__ = map_.next_value()?;
15468                        }
15469                        GeneratedField::TimeTravelRetentionMs => {
15470                            if time_travel_retention_ms__.is_some() {
15471                                return Err(serde::de::Error::duplicate_field("timeTravelRetentionMs"));
15472                            }
15473                            time_travel_retention_ms__ = 
15474                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15475                            ;
15476                        }
15477                        GeneratedField::AdaptiveParallelismStrategy => {
15478                            if adaptive_parallelism_strategy__.is_some() {
15479                                return Err(serde::de::Error::duplicate_field("adaptiveParallelismStrategy"));
15480                            }
15481                            adaptive_parallelism_strategy__ = map_.next_value()?;
15482                        }
15483                        GeneratedField::PerDatabaseIsolation => {
15484                            if per_database_isolation__.is_some() {
15485                                return Err(serde::de::Error::duplicate_field("perDatabaseIsolation"));
15486                            }
15487                            per_database_isolation__ = map_.next_value()?;
15488                        }
15489                        GeneratedField::EnforceSecret => {
15490                            if enforce_secret__.is_some() {
15491                                return Err(serde::de::Error::duplicate_field("enforceSecret"));
15492                            }
15493                            enforce_secret__ = map_.next_value()?;
15494                        }
15495                    }
15496                }
15497                Ok(SystemParams {
15498                    barrier_interval_ms: barrier_interval_ms__,
15499                    checkpoint_frequency: checkpoint_frequency__,
15500                    sstable_size_mb: sstable_size_mb__,
15501                    block_size_kb: block_size_kb__,
15502                    bloom_false_positive: bloom_false_positive__,
15503                    state_store: state_store__,
15504                    data_directory: data_directory__,
15505                    backup_storage_url: backup_storage_url__,
15506                    backup_storage_directory: backup_storage_directory__,
15507                    telemetry_enabled: telemetry_enabled__,
15508                    parallel_compact_size_mb: parallel_compact_size_mb__,
15509                    max_concurrent_creating_streaming_jobs: max_concurrent_creating_streaming_jobs__,
15510                    pause_on_next_bootstrap: pause_on_next_bootstrap__,
15511                    wasm_storage_url: wasm_storage_url__,
15512                    enable_tracing: enable_tracing__,
15513                    use_new_object_prefix_strategy: use_new_object_prefix_strategy__,
15514                    license_key: license_key__,
15515                    time_travel_retention_ms: time_travel_retention_ms__,
15516                    adaptive_parallelism_strategy: adaptive_parallelism_strategy__,
15517                    per_database_isolation: per_database_isolation__,
15518                    enforce_secret: enforce_secret__,
15519                })
15520            }
15521        }
15522        deserializer.deserialize_struct("meta.SystemParams", FIELDS, GeneratedVisitor)
15523    }
15524}
15525impl serde::Serialize for TableFragments {
15526    #[allow(deprecated)]
15527    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15528    where
15529        S: serde::Serializer,
15530    {
15531        use serde::ser::SerializeStruct;
15532        let mut len = 0;
15533        if self.table_id != 0 {
15534            len += 1;
15535        }
15536        if self.state != 0 {
15537            len += 1;
15538        }
15539        if !self.fragments.is_empty() {
15540            len += 1;
15541        }
15542        if !self.actor_status.is_empty() {
15543            len += 1;
15544        }
15545        if self.ctx.is_some() {
15546            len += 1;
15547        }
15548        if self.parallelism.is_some() {
15549            len += 1;
15550        }
15551        if self.max_parallelism.is_some() {
15552            len += 1;
15553        }
15554        if !self.node_label.is_empty() {
15555            len += 1;
15556        }
15557        if self.backfill_done {
15558            len += 1;
15559        }
15560        let mut struct_ser = serializer.serialize_struct("meta.TableFragments", len)?;
15561        if self.table_id != 0 {
15562            struct_ser.serialize_field("tableId", &self.table_id)?;
15563        }
15564        if self.state != 0 {
15565            let v = table_fragments::State::try_from(self.state)
15566                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
15567            struct_ser.serialize_field("state", &v)?;
15568        }
15569        if !self.fragments.is_empty() {
15570            struct_ser.serialize_field("fragments", &self.fragments)?;
15571        }
15572        if !self.actor_status.is_empty() {
15573            struct_ser.serialize_field("actorStatus", &self.actor_status)?;
15574        }
15575        if let Some(v) = self.ctx.as_ref() {
15576            struct_ser.serialize_field("ctx", v)?;
15577        }
15578        if let Some(v) = self.parallelism.as_ref() {
15579            struct_ser.serialize_field("parallelism", v)?;
15580        }
15581        if let Some(v) = self.max_parallelism.as_ref() {
15582            struct_ser.serialize_field("maxParallelism", v)?;
15583        }
15584        if !self.node_label.is_empty() {
15585            struct_ser.serialize_field("nodeLabel", &self.node_label)?;
15586        }
15587        if self.backfill_done {
15588            struct_ser.serialize_field("backfillDone", &self.backfill_done)?;
15589        }
15590        struct_ser.end()
15591    }
15592}
15593impl<'de> serde::Deserialize<'de> for TableFragments {
15594    #[allow(deprecated)]
15595    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15596    where
15597        D: serde::Deserializer<'de>,
15598    {
15599        const FIELDS: &[&str] = &[
15600            "table_id",
15601            "tableId",
15602            "state",
15603            "fragments",
15604            "actor_status",
15605            "actorStatus",
15606            "ctx",
15607            "parallelism",
15608            "max_parallelism",
15609            "maxParallelism",
15610            "node_label",
15611            "nodeLabel",
15612            "backfill_done",
15613            "backfillDone",
15614        ];
15615
15616        #[allow(clippy::enum_variant_names)]
15617        enum GeneratedField {
15618            TableId,
15619            State,
15620            Fragments,
15621            ActorStatus,
15622            Ctx,
15623            Parallelism,
15624            MaxParallelism,
15625            NodeLabel,
15626            BackfillDone,
15627        }
15628        impl<'de> serde::Deserialize<'de> for GeneratedField {
15629            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15630            where
15631                D: serde::Deserializer<'de>,
15632            {
15633                struct GeneratedVisitor;
15634
15635                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15636                    type Value = GeneratedField;
15637
15638                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15639                        write!(formatter, "expected one of: {:?}", &FIELDS)
15640                    }
15641
15642                    #[allow(unused_variables)]
15643                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15644                    where
15645                        E: serde::de::Error,
15646                    {
15647                        match value {
15648                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
15649                            "state" => Ok(GeneratedField::State),
15650                            "fragments" => Ok(GeneratedField::Fragments),
15651                            "actorStatus" | "actor_status" => Ok(GeneratedField::ActorStatus),
15652                            "ctx" => Ok(GeneratedField::Ctx),
15653                            "parallelism" => Ok(GeneratedField::Parallelism),
15654                            "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
15655                            "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
15656                            "backfillDone" | "backfill_done" => Ok(GeneratedField::BackfillDone),
15657                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15658                        }
15659                    }
15660                }
15661                deserializer.deserialize_identifier(GeneratedVisitor)
15662            }
15663        }
15664        struct GeneratedVisitor;
15665        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15666            type Value = TableFragments;
15667
15668            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15669                formatter.write_str("struct meta.TableFragments")
15670            }
15671
15672            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableFragments, V::Error>
15673                where
15674                    V: serde::de::MapAccess<'de>,
15675            {
15676                let mut table_id__ = None;
15677                let mut state__ = None;
15678                let mut fragments__ = None;
15679                let mut actor_status__ = None;
15680                let mut ctx__ = None;
15681                let mut parallelism__ = None;
15682                let mut max_parallelism__ = None;
15683                let mut node_label__ = None;
15684                let mut backfill_done__ = None;
15685                while let Some(k) = map_.next_key()? {
15686                    match k {
15687                        GeneratedField::TableId => {
15688                            if table_id__.is_some() {
15689                                return Err(serde::de::Error::duplicate_field("tableId"));
15690                            }
15691                            table_id__ = 
15692                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15693                            ;
15694                        }
15695                        GeneratedField::State => {
15696                            if state__.is_some() {
15697                                return Err(serde::de::Error::duplicate_field("state"));
15698                            }
15699                            state__ = Some(map_.next_value::<table_fragments::State>()? as i32);
15700                        }
15701                        GeneratedField::Fragments => {
15702                            if fragments__.is_some() {
15703                                return Err(serde::de::Error::duplicate_field("fragments"));
15704                            }
15705                            fragments__ = Some(
15706                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15707                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
15708                            );
15709                        }
15710                        GeneratedField::ActorStatus => {
15711                            if actor_status__.is_some() {
15712                                return Err(serde::de::Error::duplicate_field("actorStatus"));
15713                            }
15714                            actor_status__ = Some(
15715                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
15716                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
15717                            );
15718                        }
15719                        GeneratedField::Ctx => {
15720                            if ctx__.is_some() {
15721                                return Err(serde::de::Error::duplicate_field("ctx"));
15722                            }
15723                            ctx__ = map_.next_value()?;
15724                        }
15725                        GeneratedField::Parallelism => {
15726                            if parallelism__.is_some() {
15727                                return Err(serde::de::Error::duplicate_field("parallelism"));
15728                            }
15729                            parallelism__ = map_.next_value()?;
15730                        }
15731                        GeneratedField::MaxParallelism => {
15732                            if max_parallelism__.is_some() {
15733                                return Err(serde::de::Error::duplicate_field("maxParallelism"));
15734                            }
15735                            max_parallelism__ = 
15736                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15737                            ;
15738                        }
15739                        GeneratedField::NodeLabel => {
15740                            if node_label__.is_some() {
15741                                return Err(serde::de::Error::duplicate_field("nodeLabel"));
15742                            }
15743                            node_label__ = Some(map_.next_value()?);
15744                        }
15745                        GeneratedField::BackfillDone => {
15746                            if backfill_done__.is_some() {
15747                                return Err(serde::de::Error::duplicate_field("backfillDone"));
15748                            }
15749                            backfill_done__ = Some(map_.next_value()?);
15750                        }
15751                    }
15752                }
15753                Ok(TableFragments {
15754                    table_id: table_id__.unwrap_or_default(),
15755                    state: state__.unwrap_or_default(),
15756                    fragments: fragments__.unwrap_or_default(),
15757                    actor_status: actor_status__.unwrap_or_default(),
15758                    ctx: ctx__,
15759                    parallelism: parallelism__,
15760                    max_parallelism: max_parallelism__,
15761                    node_label: node_label__.unwrap_or_default(),
15762                    backfill_done: backfill_done__.unwrap_or_default(),
15763                })
15764            }
15765        }
15766        deserializer.deserialize_struct("meta.TableFragments", FIELDS, GeneratedVisitor)
15767    }
15768}
15769impl serde::Serialize for table_fragments::ActorStatus {
15770    #[allow(deprecated)]
15771    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15772    where
15773        S: serde::Serializer,
15774    {
15775        use serde::ser::SerializeStruct;
15776        let mut len = 0;
15777        if self.location.is_some() {
15778            len += 1;
15779        }
15780        if self.state != 0 {
15781            len += 1;
15782        }
15783        let mut struct_ser = serializer.serialize_struct("meta.TableFragments.ActorStatus", len)?;
15784        if let Some(v) = self.location.as_ref() {
15785            struct_ser.serialize_field("location", v)?;
15786        }
15787        if self.state != 0 {
15788            let v = table_fragments::actor_status::ActorState::try_from(self.state)
15789                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.state)))?;
15790            struct_ser.serialize_field("state", &v)?;
15791        }
15792        struct_ser.end()
15793    }
15794}
15795impl<'de> serde::Deserialize<'de> for table_fragments::ActorStatus {
15796    #[allow(deprecated)]
15797    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15798    where
15799        D: serde::Deserializer<'de>,
15800    {
15801        const FIELDS: &[&str] = &[
15802            "location",
15803            "state",
15804        ];
15805
15806        #[allow(clippy::enum_variant_names)]
15807        enum GeneratedField {
15808            Location,
15809            State,
15810        }
15811        impl<'de> serde::Deserialize<'de> for GeneratedField {
15812            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15813            where
15814                D: serde::Deserializer<'de>,
15815            {
15816                struct GeneratedVisitor;
15817
15818                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15819                    type Value = GeneratedField;
15820
15821                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15822                        write!(formatter, "expected one of: {:?}", &FIELDS)
15823                    }
15824
15825                    #[allow(unused_variables)]
15826                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15827                    where
15828                        E: serde::de::Error,
15829                    {
15830                        match value {
15831                            "location" => Ok(GeneratedField::Location),
15832                            "state" => Ok(GeneratedField::State),
15833                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15834                        }
15835                    }
15836                }
15837                deserializer.deserialize_identifier(GeneratedVisitor)
15838            }
15839        }
15840        struct GeneratedVisitor;
15841        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15842            type Value = table_fragments::ActorStatus;
15843
15844            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15845                formatter.write_str("struct meta.TableFragments.ActorStatus")
15846            }
15847
15848            fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::ActorStatus, V::Error>
15849                where
15850                    V: serde::de::MapAccess<'de>,
15851            {
15852                let mut location__ = None;
15853                let mut state__ = None;
15854                while let Some(k) = map_.next_key()? {
15855                    match k {
15856                        GeneratedField::Location => {
15857                            if location__.is_some() {
15858                                return Err(serde::de::Error::duplicate_field("location"));
15859                            }
15860                            location__ = map_.next_value()?;
15861                        }
15862                        GeneratedField::State => {
15863                            if state__.is_some() {
15864                                return Err(serde::de::Error::duplicate_field("state"));
15865                            }
15866                            state__ = Some(map_.next_value::<table_fragments::actor_status::ActorState>()? as i32);
15867                        }
15868                    }
15869                }
15870                Ok(table_fragments::ActorStatus {
15871                    location: location__,
15872                    state: state__.unwrap_or_default(),
15873                })
15874            }
15875        }
15876        deserializer.deserialize_struct("meta.TableFragments.ActorStatus", FIELDS, GeneratedVisitor)
15877    }
15878}
15879impl serde::Serialize for table_fragments::actor_status::ActorState {
15880    #[allow(deprecated)]
15881    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15882    where
15883        S: serde::Serializer,
15884    {
15885        let variant = match self {
15886            Self::Unspecified => "UNSPECIFIED",
15887            Self::Inactive => "INACTIVE",
15888            Self::Running => "RUNNING",
15889        };
15890        serializer.serialize_str(variant)
15891    }
15892}
15893impl<'de> serde::Deserialize<'de> for table_fragments::actor_status::ActorState {
15894    #[allow(deprecated)]
15895    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15896    where
15897        D: serde::Deserializer<'de>,
15898    {
15899        const FIELDS: &[&str] = &[
15900            "UNSPECIFIED",
15901            "INACTIVE",
15902            "RUNNING",
15903        ];
15904
15905        struct GeneratedVisitor;
15906
15907        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15908            type Value = table_fragments::actor_status::ActorState;
15909
15910            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15911                write!(formatter, "expected one of: {:?}", &FIELDS)
15912            }
15913
15914            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
15915            where
15916                E: serde::de::Error,
15917            {
15918                i32::try_from(v)
15919                    .ok()
15920                    .and_then(|x| x.try_into().ok())
15921                    .ok_or_else(|| {
15922                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
15923                    })
15924            }
15925
15926            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
15927            where
15928                E: serde::de::Error,
15929            {
15930                i32::try_from(v)
15931                    .ok()
15932                    .and_then(|x| x.try_into().ok())
15933                    .ok_or_else(|| {
15934                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
15935                    })
15936            }
15937
15938            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
15939            where
15940                E: serde::de::Error,
15941            {
15942                match value {
15943                    "UNSPECIFIED" => Ok(table_fragments::actor_status::ActorState::Unspecified),
15944                    "INACTIVE" => Ok(table_fragments::actor_status::ActorState::Inactive),
15945                    "RUNNING" => Ok(table_fragments::actor_status::ActorState::Running),
15946                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
15947                }
15948            }
15949        }
15950        deserializer.deserialize_any(GeneratedVisitor)
15951    }
15952}
15953impl serde::Serialize for table_fragments::Fragment {
15954    #[allow(deprecated)]
15955    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15956    where
15957        S: serde::Serializer,
15958    {
15959        use serde::ser::SerializeStruct;
15960        let mut len = 0;
15961        if self.fragment_id != 0 {
15962            len += 1;
15963        }
15964        if self.fragment_type_mask != 0 {
15965            len += 1;
15966        }
15967        if self.distribution_type != 0 {
15968            len += 1;
15969        }
15970        if !self.actors.is_empty() {
15971            len += 1;
15972        }
15973        if !self.state_table_ids.is_empty() {
15974            len += 1;
15975        }
15976        if !self.upstream_fragment_ids.is_empty() {
15977            len += 1;
15978        }
15979        if self.maybe_vnode_count.is_some() {
15980            len += 1;
15981        }
15982        if self.nodes.is_some() {
15983            len += 1;
15984        }
15985        let mut struct_ser = serializer.serialize_struct("meta.TableFragments.Fragment", len)?;
15986        if self.fragment_id != 0 {
15987            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
15988        }
15989        if self.fragment_type_mask != 0 {
15990            struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
15991        }
15992        if self.distribution_type != 0 {
15993            let v = table_fragments::fragment::FragmentDistributionType::try_from(self.distribution_type)
15994                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.distribution_type)))?;
15995            struct_ser.serialize_field("distributionType", &v)?;
15996        }
15997        if !self.actors.is_empty() {
15998            struct_ser.serialize_field("actors", &self.actors)?;
15999        }
16000        if !self.state_table_ids.is_empty() {
16001            struct_ser.serialize_field("stateTableIds", &self.state_table_ids)?;
16002        }
16003        if !self.upstream_fragment_ids.is_empty() {
16004            struct_ser.serialize_field("upstreamFragmentIds", &self.upstream_fragment_ids)?;
16005        }
16006        if let Some(v) = self.maybe_vnode_count.as_ref() {
16007            struct_ser.serialize_field("maybeVnodeCount", v)?;
16008        }
16009        if let Some(v) = self.nodes.as_ref() {
16010            struct_ser.serialize_field("nodes", v)?;
16011        }
16012        struct_ser.end()
16013    }
16014}
16015impl<'de> serde::Deserialize<'de> for table_fragments::Fragment {
16016    #[allow(deprecated)]
16017    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16018    where
16019        D: serde::Deserializer<'de>,
16020    {
16021        const FIELDS: &[&str] = &[
16022            "fragment_id",
16023            "fragmentId",
16024            "fragment_type_mask",
16025            "fragmentTypeMask",
16026            "distribution_type",
16027            "distributionType",
16028            "actors",
16029            "state_table_ids",
16030            "stateTableIds",
16031            "upstream_fragment_ids",
16032            "upstreamFragmentIds",
16033            "maybe_vnode_count",
16034            "maybeVnodeCount",
16035            "nodes",
16036        ];
16037
16038        #[allow(clippy::enum_variant_names)]
16039        enum GeneratedField {
16040            FragmentId,
16041            FragmentTypeMask,
16042            DistributionType,
16043            Actors,
16044            StateTableIds,
16045            UpstreamFragmentIds,
16046            MaybeVnodeCount,
16047            Nodes,
16048        }
16049        impl<'de> serde::Deserialize<'de> for GeneratedField {
16050            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16051            where
16052                D: serde::Deserializer<'de>,
16053            {
16054                struct GeneratedVisitor;
16055
16056                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16057                    type Value = GeneratedField;
16058
16059                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16060                        write!(formatter, "expected one of: {:?}", &FIELDS)
16061                    }
16062
16063                    #[allow(unused_variables)]
16064                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16065                    where
16066                        E: serde::de::Error,
16067                    {
16068                        match value {
16069                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
16070                            "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
16071                            "distributionType" | "distribution_type" => Ok(GeneratedField::DistributionType),
16072                            "actors" => Ok(GeneratedField::Actors),
16073                            "stateTableIds" | "state_table_ids" => Ok(GeneratedField::StateTableIds),
16074                            "upstreamFragmentIds" | "upstream_fragment_ids" => Ok(GeneratedField::UpstreamFragmentIds),
16075                            "maybeVnodeCount" | "maybe_vnode_count" => Ok(GeneratedField::MaybeVnodeCount),
16076                            "nodes" => Ok(GeneratedField::Nodes),
16077                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16078                        }
16079                    }
16080                }
16081                deserializer.deserialize_identifier(GeneratedVisitor)
16082            }
16083        }
16084        struct GeneratedVisitor;
16085        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16086            type Value = table_fragments::Fragment;
16087
16088            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16089                formatter.write_str("struct meta.TableFragments.Fragment")
16090            }
16091
16092            fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_fragments::Fragment, V::Error>
16093                where
16094                    V: serde::de::MapAccess<'de>,
16095            {
16096                let mut fragment_id__ = None;
16097                let mut fragment_type_mask__ = None;
16098                let mut distribution_type__ = None;
16099                let mut actors__ = None;
16100                let mut state_table_ids__ = None;
16101                let mut upstream_fragment_ids__ = None;
16102                let mut maybe_vnode_count__ = None;
16103                let mut nodes__ = None;
16104                while let Some(k) = map_.next_key()? {
16105                    match k {
16106                        GeneratedField::FragmentId => {
16107                            if fragment_id__.is_some() {
16108                                return Err(serde::de::Error::duplicate_field("fragmentId"));
16109                            }
16110                            fragment_id__ = 
16111                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16112                            ;
16113                        }
16114                        GeneratedField::FragmentTypeMask => {
16115                            if fragment_type_mask__.is_some() {
16116                                return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
16117                            }
16118                            fragment_type_mask__ = 
16119                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16120                            ;
16121                        }
16122                        GeneratedField::DistributionType => {
16123                            if distribution_type__.is_some() {
16124                                return Err(serde::de::Error::duplicate_field("distributionType"));
16125                            }
16126                            distribution_type__ = Some(map_.next_value::<table_fragments::fragment::FragmentDistributionType>()? as i32);
16127                        }
16128                        GeneratedField::Actors => {
16129                            if actors__.is_some() {
16130                                return Err(serde::de::Error::duplicate_field("actors"));
16131                            }
16132                            actors__ = Some(map_.next_value()?);
16133                        }
16134                        GeneratedField::StateTableIds => {
16135                            if state_table_ids__.is_some() {
16136                                return Err(serde::de::Error::duplicate_field("stateTableIds"));
16137                            }
16138                            state_table_ids__ = 
16139                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16140                                    .into_iter().map(|x| x.0).collect())
16141                            ;
16142                        }
16143                        GeneratedField::UpstreamFragmentIds => {
16144                            if upstream_fragment_ids__.is_some() {
16145                                return Err(serde::de::Error::duplicate_field("upstreamFragmentIds"));
16146                            }
16147                            upstream_fragment_ids__ = 
16148                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
16149                                    .into_iter().map(|x| x.0).collect())
16150                            ;
16151                        }
16152                        GeneratedField::MaybeVnodeCount => {
16153                            if maybe_vnode_count__.is_some() {
16154                                return Err(serde::de::Error::duplicate_field("maybeVnodeCount"));
16155                            }
16156                            maybe_vnode_count__ = 
16157                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
16158                            ;
16159                        }
16160                        GeneratedField::Nodes => {
16161                            if nodes__.is_some() {
16162                                return Err(serde::de::Error::duplicate_field("nodes"));
16163                            }
16164                            nodes__ = map_.next_value()?;
16165                        }
16166                    }
16167                }
16168                Ok(table_fragments::Fragment {
16169                    fragment_id: fragment_id__.unwrap_or_default(),
16170                    fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
16171                    distribution_type: distribution_type__.unwrap_or_default(),
16172                    actors: actors__.unwrap_or_default(),
16173                    state_table_ids: state_table_ids__.unwrap_or_default(),
16174                    upstream_fragment_ids: upstream_fragment_ids__.unwrap_or_default(),
16175                    maybe_vnode_count: maybe_vnode_count__,
16176                    nodes: nodes__,
16177                })
16178            }
16179        }
16180        deserializer.deserialize_struct("meta.TableFragments.Fragment", FIELDS, GeneratedVisitor)
16181    }
16182}
16183impl serde::Serialize for table_fragments::fragment::FragmentDistributionType {
16184    #[allow(deprecated)]
16185    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16186    where
16187        S: serde::Serializer,
16188    {
16189        let variant = match self {
16190            Self::Unspecified => "UNSPECIFIED",
16191            Self::Single => "SINGLE",
16192            Self::Hash => "HASH",
16193        };
16194        serializer.serialize_str(variant)
16195    }
16196}
16197impl<'de> serde::Deserialize<'de> for table_fragments::fragment::FragmentDistributionType {
16198    #[allow(deprecated)]
16199    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16200    where
16201        D: serde::Deserializer<'de>,
16202    {
16203        const FIELDS: &[&str] = &[
16204            "UNSPECIFIED",
16205            "SINGLE",
16206            "HASH",
16207        ];
16208
16209        struct GeneratedVisitor;
16210
16211        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16212            type Value = table_fragments::fragment::FragmentDistributionType;
16213
16214            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16215                write!(formatter, "expected one of: {:?}", &FIELDS)
16216            }
16217
16218            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16219            where
16220                E: serde::de::Error,
16221            {
16222                i32::try_from(v)
16223                    .ok()
16224                    .and_then(|x| x.try_into().ok())
16225                    .ok_or_else(|| {
16226                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16227                    })
16228            }
16229
16230            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16231            where
16232                E: serde::de::Error,
16233            {
16234                i32::try_from(v)
16235                    .ok()
16236                    .and_then(|x| x.try_into().ok())
16237                    .ok_or_else(|| {
16238                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16239                    })
16240            }
16241
16242            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16243            where
16244                E: serde::de::Error,
16245            {
16246                match value {
16247                    "UNSPECIFIED" => Ok(table_fragments::fragment::FragmentDistributionType::Unspecified),
16248                    "SINGLE" => Ok(table_fragments::fragment::FragmentDistributionType::Single),
16249                    "HASH" => Ok(table_fragments::fragment::FragmentDistributionType::Hash),
16250                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16251                }
16252            }
16253        }
16254        deserializer.deserialize_any(GeneratedVisitor)
16255    }
16256}
16257impl serde::Serialize for table_fragments::State {
16258    #[allow(deprecated)]
16259    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16260    where
16261        S: serde::Serializer,
16262    {
16263        let variant = match self {
16264            Self::Unspecified => "UNSPECIFIED",
16265            Self::Initial => "INITIAL",
16266            Self::Creating => "CREATING",
16267            Self::Created => "CREATED",
16268        };
16269        serializer.serialize_str(variant)
16270    }
16271}
16272impl<'de> serde::Deserialize<'de> for table_fragments::State {
16273    #[allow(deprecated)]
16274    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16275    where
16276        D: serde::Deserializer<'de>,
16277    {
16278        const FIELDS: &[&str] = &[
16279            "UNSPECIFIED",
16280            "INITIAL",
16281            "CREATING",
16282            "CREATED",
16283        ];
16284
16285        struct GeneratedVisitor;
16286
16287        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16288            type Value = table_fragments::State;
16289
16290            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16291                write!(formatter, "expected one of: {:?}", &FIELDS)
16292            }
16293
16294            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16295            where
16296                E: serde::de::Error,
16297            {
16298                i32::try_from(v)
16299                    .ok()
16300                    .and_then(|x| x.try_into().ok())
16301                    .ok_or_else(|| {
16302                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16303                    })
16304            }
16305
16306            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16307            where
16308                E: serde::de::Error,
16309            {
16310                i32::try_from(v)
16311                    .ok()
16312                    .and_then(|x| x.try_into().ok())
16313                    .ok_or_else(|| {
16314                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16315                    })
16316            }
16317
16318            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16319            where
16320                E: serde::de::Error,
16321            {
16322                match value {
16323                    "UNSPECIFIED" => Ok(table_fragments::State::Unspecified),
16324                    "INITIAL" => Ok(table_fragments::State::Initial),
16325                    "CREATING" => Ok(table_fragments::State::Creating),
16326                    "CREATED" => Ok(table_fragments::State::Created),
16327                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16328                }
16329            }
16330        }
16331        deserializer.deserialize_any(GeneratedVisitor)
16332    }
16333}
16334impl serde::Serialize for TableParallelism {
16335    #[allow(deprecated)]
16336    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16337    where
16338        S: serde::Serializer,
16339    {
16340        use serde::ser::SerializeStruct;
16341        let mut len = 0;
16342        if self.parallelism.is_some() {
16343            len += 1;
16344        }
16345        let mut struct_ser = serializer.serialize_struct("meta.TableParallelism", len)?;
16346        if let Some(v) = self.parallelism.as_ref() {
16347            match v {
16348                table_parallelism::Parallelism::Fixed(v) => {
16349                    struct_ser.serialize_field("fixed", v)?;
16350                }
16351                table_parallelism::Parallelism::Auto(v) => {
16352                    struct_ser.serialize_field("auto", v)?;
16353                }
16354                table_parallelism::Parallelism::Custom(v) => {
16355                    struct_ser.serialize_field("custom", v)?;
16356                }
16357                table_parallelism::Parallelism::Adaptive(v) => {
16358                    struct_ser.serialize_field("adaptive", v)?;
16359                }
16360            }
16361        }
16362        struct_ser.end()
16363    }
16364}
16365impl<'de> serde::Deserialize<'de> for TableParallelism {
16366    #[allow(deprecated)]
16367    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16368    where
16369        D: serde::Deserializer<'de>,
16370    {
16371        const FIELDS: &[&str] = &[
16372            "fixed",
16373            "auto",
16374            "custom",
16375            "adaptive",
16376        ];
16377
16378        #[allow(clippy::enum_variant_names)]
16379        enum GeneratedField {
16380            Fixed,
16381            Auto,
16382            Custom,
16383            Adaptive,
16384        }
16385        impl<'de> serde::Deserialize<'de> for GeneratedField {
16386            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16387            where
16388                D: serde::Deserializer<'de>,
16389            {
16390                struct GeneratedVisitor;
16391
16392                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16393                    type Value = GeneratedField;
16394
16395                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16396                        write!(formatter, "expected one of: {:?}", &FIELDS)
16397                    }
16398
16399                    #[allow(unused_variables)]
16400                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16401                    where
16402                        E: serde::de::Error,
16403                    {
16404                        match value {
16405                            "fixed" => Ok(GeneratedField::Fixed),
16406                            "auto" => Ok(GeneratedField::Auto),
16407                            "custom" => Ok(GeneratedField::Custom),
16408                            "adaptive" => Ok(GeneratedField::Adaptive),
16409                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16410                        }
16411                    }
16412                }
16413                deserializer.deserialize_identifier(GeneratedVisitor)
16414            }
16415        }
16416        struct GeneratedVisitor;
16417        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16418            type Value = TableParallelism;
16419
16420            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16421                formatter.write_str("struct meta.TableParallelism")
16422            }
16423
16424            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableParallelism, V::Error>
16425                where
16426                    V: serde::de::MapAccess<'de>,
16427            {
16428                let mut parallelism__ = None;
16429                while let Some(k) = map_.next_key()? {
16430                    match k {
16431                        GeneratedField::Fixed => {
16432                            if parallelism__.is_some() {
16433                                return Err(serde::de::Error::duplicate_field("fixed"));
16434                            }
16435                            parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Fixed)
16436;
16437                        }
16438                        GeneratedField::Auto => {
16439                            if parallelism__.is_some() {
16440                                return Err(serde::de::Error::duplicate_field("auto"));
16441                            }
16442                            parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Auto)
16443;
16444                        }
16445                        GeneratedField::Custom => {
16446                            if parallelism__.is_some() {
16447                                return Err(serde::de::Error::duplicate_field("custom"));
16448                            }
16449                            parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Custom)
16450;
16451                        }
16452                        GeneratedField::Adaptive => {
16453                            if parallelism__.is_some() {
16454                                return Err(serde::de::Error::duplicate_field("adaptive"));
16455                            }
16456                            parallelism__ = map_.next_value::<::std::option::Option<_>>()?.map(table_parallelism::Parallelism::Adaptive)
16457;
16458                        }
16459                    }
16460                }
16461                Ok(TableParallelism {
16462                    parallelism: parallelism__,
16463                })
16464            }
16465        }
16466        deserializer.deserialize_struct("meta.TableParallelism", FIELDS, GeneratedVisitor)
16467    }
16468}
16469impl serde::Serialize for table_parallelism::AdaptiveParallelism {
16470    #[allow(deprecated)]
16471    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16472    where
16473        S: serde::Serializer,
16474    {
16475        use serde::ser::SerializeStruct;
16476        let len = 0;
16477        let struct_ser = serializer.serialize_struct("meta.TableParallelism.AdaptiveParallelism", len)?;
16478        struct_ser.end()
16479    }
16480}
16481impl<'de> serde::Deserialize<'de> for table_parallelism::AdaptiveParallelism {
16482    #[allow(deprecated)]
16483    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16484    where
16485        D: serde::Deserializer<'de>,
16486    {
16487        const FIELDS: &[&str] = &[
16488        ];
16489
16490        #[allow(clippy::enum_variant_names)]
16491        enum GeneratedField {
16492        }
16493        impl<'de> serde::Deserialize<'de> for GeneratedField {
16494            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16495            where
16496                D: serde::Deserializer<'de>,
16497            {
16498                struct GeneratedVisitor;
16499
16500                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16501                    type Value = GeneratedField;
16502
16503                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16504                        write!(formatter, "expected one of: {:?}", &FIELDS)
16505                    }
16506
16507                    #[allow(unused_variables)]
16508                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16509                    where
16510                        E: serde::de::Error,
16511                    {
16512                            Err(serde::de::Error::unknown_field(value, FIELDS))
16513                    }
16514                }
16515                deserializer.deserialize_identifier(GeneratedVisitor)
16516            }
16517        }
16518        struct GeneratedVisitor;
16519        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16520            type Value = table_parallelism::AdaptiveParallelism;
16521
16522            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16523                formatter.write_str("struct meta.TableParallelism.AdaptiveParallelism")
16524            }
16525
16526            fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AdaptiveParallelism, V::Error>
16527                where
16528                    V: serde::de::MapAccess<'de>,
16529            {
16530                while map_.next_key::<GeneratedField>()?.is_some() {
16531                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16532                }
16533                Ok(table_parallelism::AdaptiveParallelism {
16534                })
16535            }
16536        }
16537        deserializer.deserialize_struct("meta.TableParallelism.AdaptiveParallelism", FIELDS, GeneratedVisitor)
16538    }
16539}
16540impl serde::Serialize for table_parallelism::AutoParallelism {
16541    #[allow(deprecated)]
16542    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16543    where
16544        S: serde::Serializer,
16545    {
16546        use serde::ser::SerializeStruct;
16547        let len = 0;
16548        let struct_ser = serializer.serialize_struct("meta.TableParallelism.AutoParallelism", len)?;
16549        struct_ser.end()
16550    }
16551}
16552impl<'de> serde::Deserialize<'de> for table_parallelism::AutoParallelism {
16553    #[allow(deprecated)]
16554    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16555    where
16556        D: serde::Deserializer<'de>,
16557    {
16558        const FIELDS: &[&str] = &[
16559        ];
16560
16561        #[allow(clippy::enum_variant_names)]
16562        enum GeneratedField {
16563        }
16564        impl<'de> serde::Deserialize<'de> for GeneratedField {
16565            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16566            where
16567                D: serde::Deserializer<'de>,
16568            {
16569                struct GeneratedVisitor;
16570
16571                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16572                    type Value = GeneratedField;
16573
16574                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16575                        write!(formatter, "expected one of: {:?}", &FIELDS)
16576                    }
16577
16578                    #[allow(unused_variables)]
16579                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16580                    where
16581                        E: serde::de::Error,
16582                    {
16583                            Err(serde::de::Error::unknown_field(value, FIELDS))
16584                    }
16585                }
16586                deserializer.deserialize_identifier(GeneratedVisitor)
16587            }
16588        }
16589        struct GeneratedVisitor;
16590        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16591            type Value = table_parallelism::AutoParallelism;
16592
16593            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16594                formatter.write_str("struct meta.TableParallelism.AutoParallelism")
16595            }
16596
16597            fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::AutoParallelism, V::Error>
16598                where
16599                    V: serde::de::MapAccess<'de>,
16600            {
16601                while map_.next_key::<GeneratedField>()?.is_some() {
16602                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16603                }
16604                Ok(table_parallelism::AutoParallelism {
16605                })
16606            }
16607        }
16608        deserializer.deserialize_struct("meta.TableParallelism.AutoParallelism", FIELDS, GeneratedVisitor)
16609    }
16610}
16611impl serde::Serialize for table_parallelism::CustomParallelism {
16612    #[allow(deprecated)]
16613    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16614    where
16615        S: serde::Serializer,
16616    {
16617        use serde::ser::SerializeStruct;
16618        let len = 0;
16619        let struct_ser = serializer.serialize_struct("meta.TableParallelism.CustomParallelism", len)?;
16620        struct_ser.end()
16621    }
16622}
16623impl<'de> serde::Deserialize<'de> for table_parallelism::CustomParallelism {
16624    #[allow(deprecated)]
16625    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16626    where
16627        D: serde::Deserializer<'de>,
16628    {
16629        const FIELDS: &[&str] = &[
16630        ];
16631
16632        #[allow(clippy::enum_variant_names)]
16633        enum GeneratedField {
16634        }
16635        impl<'de> serde::Deserialize<'de> for GeneratedField {
16636            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16637            where
16638                D: serde::Deserializer<'de>,
16639            {
16640                struct GeneratedVisitor;
16641
16642                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16643                    type Value = GeneratedField;
16644
16645                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16646                        write!(formatter, "expected one of: {:?}", &FIELDS)
16647                    }
16648
16649                    #[allow(unused_variables)]
16650                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16651                    where
16652                        E: serde::de::Error,
16653                    {
16654                            Err(serde::de::Error::unknown_field(value, FIELDS))
16655                    }
16656                }
16657                deserializer.deserialize_identifier(GeneratedVisitor)
16658            }
16659        }
16660        struct GeneratedVisitor;
16661        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16662            type Value = table_parallelism::CustomParallelism;
16663
16664            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16665                formatter.write_str("struct meta.TableParallelism.CustomParallelism")
16666            }
16667
16668            fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::CustomParallelism, V::Error>
16669                where
16670                    V: serde::de::MapAccess<'de>,
16671            {
16672                while map_.next_key::<GeneratedField>()?.is_some() {
16673                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
16674                }
16675                Ok(table_parallelism::CustomParallelism {
16676                })
16677            }
16678        }
16679        deserializer.deserialize_struct("meta.TableParallelism.CustomParallelism", FIELDS, GeneratedVisitor)
16680    }
16681}
16682impl serde::Serialize for table_parallelism::FixedParallelism {
16683    #[allow(deprecated)]
16684    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16685    where
16686        S: serde::Serializer,
16687    {
16688        use serde::ser::SerializeStruct;
16689        let mut len = 0;
16690        if self.parallelism != 0 {
16691            len += 1;
16692        }
16693        let mut struct_ser = serializer.serialize_struct("meta.TableParallelism.FixedParallelism", len)?;
16694        if self.parallelism != 0 {
16695            struct_ser.serialize_field("parallelism", &self.parallelism)?;
16696        }
16697        struct_ser.end()
16698    }
16699}
16700impl<'de> serde::Deserialize<'de> for table_parallelism::FixedParallelism {
16701    #[allow(deprecated)]
16702    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16703    where
16704        D: serde::Deserializer<'de>,
16705    {
16706        const FIELDS: &[&str] = &[
16707            "parallelism",
16708        ];
16709
16710        #[allow(clippy::enum_variant_names)]
16711        enum GeneratedField {
16712            Parallelism,
16713        }
16714        impl<'de> serde::Deserialize<'de> for GeneratedField {
16715            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16716            where
16717                D: serde::Deserializer<'de>,
16718            {
16719                struct GeneratedVisitor;
16720
16721                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16722                    type Value = GeneratedField;
16723
16724                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16725                        write!(formatter, "expected one of: {:?}", &FIELDS)
16726                    }
16727
16728                    #[allow(unused_variables)]
16729                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16730                    where
16731                        E: serde::de::Error,
16732                    {
16733                        match value {
16734                            "parallelism" => Ok(GeneratedField::Parallelism),
16735                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16736                        }
16737                    }
16738                }
16739                deserializer.deserialize_identifier(GeneratedVisitor)
16740            }
16741        }
16742        struct GeneratedVisitor;
16743        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16744            type Value = table_parallelism::FixedParallelism;
16745
16746            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16747                formatter.write_str("struct meta.TableParallelism.FixedParallelism")
16748            }
16749
16750            fn visit_map<V>(self, mut map_: V) -> std::result::Result<table_parallelism::FixedParallelism, V::Error>
16751                where
16752                    V: serde::de::MapAccess<'de>,
16753            {
16754                let mut parallelism__ = None;
16755                while let Some(k) = map_.next_key()? {
16756                    match k {
16757                        GeneratedField::Parallelism => {
16758                            if parallelism__.is_some() {
16759                                return Err(serde::de::Error::duplicate_field("parallelism"));
16760                            }
16761                            parallelism__ = 
16762                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
16763                            ;
16764                        }
16765                    }
16766                }
16767                Ok(table_parallelism::FixedParallelism {
16768                    parallelism: parallelism__.unwrap_or_default(),
16769                })
16770            }
16771        }
16772        deserializer.deserialize_struct("meta.TableParallelism.FixedParallelism", FIELDS, GeneratedVisitor)
16773    }
16774}
16775impl serde::Serialize for TelemetryInfoResponse {
16776    #[allow(deprecated)]
16777    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16778    where
16779        S: serde::Serializer,
16780    {
16781        use serde::ser::SerializeStruct;
16782        let mut len = 0;
16783        if self.tracking_id.is_some() {
16784            len += 1;
16785        }
16786        let mut struct_ser = serializer.serialize_struct("meta.TelemetryInfoResponse", len)?;
16787        if let Some(v) = self.tracking_id.as_ref() {
16788            struct_ser.serialize_field("trackingId", v)?;
16789        }
16790        struct_ser.end()
16791    }
16792}
16793impl<'de> serde::Deserialize<'de> for TelemetryInfoResponse {
16794    #[allow(deprecated)]
16795    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16796    where
16797        D: serde::Deserializer<'de>,
16798    {
16799        const FIELDS: &[&str] = &[
16800            "tracking_id",
16801            "trackingId",
16802        ];
16803
16804        #[allow(clippy::enum_variant_names)]
16805        enum GeneratedField {
16806            TrackingId,
16807        }
16808        impl<'de> serde::Deserialize<'de> for GeneratedField {
16809            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16810            where
16811                D: serde::Deserializer<'de>,
16812            {
16813                struct GeneratedVisitor;
16814
16815                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16816                    type Value = GeneratedField;
16817
16818                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16819                        write!(formatter, "expected one of: {:?}", &FIELDS)
16820                    }
16821
16822                    #[allow(unused_variables)]
16823                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16824                    where
16825                        E: serde::de::Error,
16826                    {
16827                        match value {
16828                            "trackingId" | "tracking_id" => Ok(GeneratedField::TrackingId),
16829                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16830                        }
16831                    }
16832                }
16833                deserializer.deserialize_identifier(GeneratedVisitor)
16834            }
16835        }
16836        struct GeneratedVisitor;
16837        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16838            type Value = TelemetryInfoResponse;
16839
16840            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16841                formatter.write_str("struct meta.TelemetryInfoResponse")
16842            }
16843
16844            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TelemetryInfoResponse, V::Error>
16845                where
16846                    V: serde::de::MapAccess<'de>,
16847            {
16848                let mut tracking_id__ = None;
16849                while let Some(k) = map_.next_key()? {
16850                    match k {
16851                        GeneratedField::TrackingId => {
16852                            if tracking_id__.is_some() {
16853                                return Err(serde::de::Error::duplicate_field("trackingId"));
16854                            }
16855                            tracking_id__ = map_.next_value()?;
16856                        }
16857                    }
16858                }
16859                Ok(TelemetryInfoResponse {
16860                    tracking_id: tracking_id__,
16861                })
16862            }
16863        }
16864        deserializer.deserialize_struct("meta.TelemetryInfoResponse", FIELDS, GeneratedVisitor)
16865    }
16866}
16867impl serde::Serialize for ThrottleTarget {
16868    #[allow(deprecated)]
16869    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16870    where
16871        S: serde::Serializer,
16872    {
16873        let variant = match self {
16874            Self::Unspecified => "THROTTLE_TARGET_UNSPECIFIED",
16875            Self::Source => "SOURCE",
16876            Self::Mv => "MV",
16877            Self::TableWithSource => "TABLE_WITH_SOURCE",
16878            Self::CdcTable => "CDC_TABLE",
16879            Self::TableDml => "TABLE_DML",
16880            Self::Sink => "SINK",
16881            Self::Fragment => "FRAGMENT",
16882        };
16883        serializer.serialize_str(variant)
16884    }
16885}
16886impl<'de> serde::Deserialize<'de> for ThrottleTarget {
16887    #[allow(deprecated)]
16888    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16889    where
16890        D: serde::Deserializer<'de>,
16891    {
16892        const FIELDS: &[&str] = &[
16893            "THROTTLE_TARGET_UNSPECIFIED",
16894            "SOURCE",
16895            "MV",
16896            "TABLE_WITH_SOURCE",
16897            "CDC_TABLE",
16898            "TABLE_DML",
16899            "SINK",
16900            "FRAGMENT",
16901        ];
16902
16903        struct GeneratedVisitor;
16904
16905        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16906            type Value = ThrottleTarget;
16907
16908            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16909                write!(formatter, "expected one of: {:?}", &FIELDS)
16910            }
16911
16912            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
16913            where
16914                E: serde::de::Error,
16915            {
16916                i32::try_from(v)
16917                    .ok()
16918                    .and_then(|x| x.try_into().ok())
16919                    .ok_or_else(|| {
16920                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
16921                    })
16922            }
16923
16924            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
16925            where
16926                E: serde::de::Error,
16927            {
16928                i32::try_from(v)
16929                    .ok()
16930                    .and_then(|x| x.try_into().ok())
16931                    .ok_or_else(|| {
16932                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
16933                    })
16934            }
16935
16936            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
16937            where
16938                E: serde::de::Error,
16939            {
16940                match value {
16941                    "THROTTLE_TARGET_UNSPECIFIED" => Ok(ThrottleTarget::Unspecified),
16942                    "SOURCE" => Ok(ThrottleTarget::Source),
16943                    "MV" => Ok(ThrottleTarget::Mv),
16944                    "TABLE_WITH_SOURCE" => Ok(ThrottleTarget::TableWithSource),
16945                    "CDC_TABLE" => Ok(ThrottleTarget::CdcTable),
16946                    "TABLE_DML" => Ok(ThrottleTarget::TableDml),
16947                    "SINK" => Ok(ThrottleTarget::Sink),
16948                    "FRAGMENT" => Ok(ThrottleTarget::Fragment),
16949                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
16950                }
16951            }
16952        }
16953        deserializer.deserialize_any(GeneratedVisitor)
16954    }
16955}
16956impl serde::Serialize for UpdateStreamingJobNodeLabelsRequest {
16957    #[allow(deprecated)]
16958    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
16959    where
16960        S: serde::Serializer,
16961    {
16962        use serde::ser::SerializeStruct;
16963        let mut len = 0;
16964        if self.id != 0 {
16965            len += 1;
16966        }
16967        if !self.node_label.is_empty() {
16968            len += 1;
16969        }
16970        let mut struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", len)?;
16971        if self.id != 0 {
16972            struct_ser.serialize_field("id", &self.id)?;
16973        }
16974        if !self.node_label.is_empty() {
16975            struct_ser.serialize_field("nodeLabel", &self.node_label)?;
16976        }
16977        struct_ser.end()
16978    }
16979}
16980impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsRequest {
16981    #[allow(deprecated)]
16982    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
16983    where
16984        D: serde::Deserializer<'de>,
16985    {
16986        const FIELDS: &[&str] = &[
16987            "id",
16988            "node_label",
16989            "nodeLabel",
16990        ];
16991
16992        #[allow(clippy::enum_variant_names)]
16993        enum GeneratedField {
16994            Id,
16995            NodeLabel,
16996        }
16997        impl<'de> serde::Deserialize<'de> for GeneratedField {
16998            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
16999            where
17000                D: serde::Deserializer<'de>,
17001            {
17002                struct GeneratedVisitor;
17003
17004                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17005                    type Value = GeneratedField;
17006
17007                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17008                        write!(formatter, "expected one of: {:?}", &FIELDS)
17009                    }
17010
17011                    #[allow(unused_variables)]
17012                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17013                    where
17014                        E: serde::de::Error,
17015                    {
17016                        match value {
17017                            "id" => Ok(GeneratedField::Id),
17018                            "nodeLabel" | "node_label" => Ok(GeneratedField::NodeLabel),
17019                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17020                        }
17021                    }
17022                }
17023                deserializer.deserialize_identifier(GeneratedVisitor)
17024            }
17025        }
17026        struct GeneratedVisitor;
17027        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17028            type Value = UpdateStreamingJobNodeLabelsRequest;
17029
17030            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17031                formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsRequest")
17032            }
17033
17034            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsRequest, V::Error>
17035                where
17036                    V: serde::de::MapAccess<'de>,
17037            {
17038                let mut id__ = None;
17039                let mut node_label__ = None;
17040                while let Some(k) = map_.next_key()? {
17041                    match k {
17042                        GeneratedField::Id => {
17043                            if id__.is_some() {
17044                                return Err(serde::de::Error::duplicate_field("id"));
17045                            }
17046                            id__ = 
17047                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
17048                            ;
17049                        }
17050                        GeneratedField::NodeLabel => {
17051                            if node_label__.is_some() {
17052                                return Err(serde::de::Error::duplicate_field("nodeLabel"));
17053                            }
17054                            node_label__ = Some(map_.next_value()?);
17055                        }
17056                    }
17057                }
17058                Ok(UpdateStreamingJobNodeLabelsRequest {
17059                    id: id__.unwrap_or_default(),
17060                    node_label: node_label__.unwrap_or_default(),
17061                })
17062            }
17063        }
17064        deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsRequest", FIELDS, GeneratedVisitor)
17065    }
17066}
17067impl serde::Serialize for UpdateStreamingJobNodeLabelsResponse {
17068    #[allow(deprecated)]
17069    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17070    where
17071        S: serde::Serializer,
17072    {
17073        use serde::ser::SerializeStruct;
17074        let len = 0;
17075        let struct_ser = serializer.serialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", len)?;
17076        struct_ser.end()
17077    }
17078}
17079impl<'de> serde::Deserialize<'de> for UpdateStreamingJobNodeLabelsResponse {
17080    #[allow(deprecated)]
17081    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17082    where
17083        D: serde::Deserializer<'de>,
17084    {
17085        const FIELDS: &[&str] = &[
17086        ];
17087
17088        #[allow(clippy::enum_variant_names)]
17089        enum GeneratedField {
17090        }
17091        impl<'de> serde::Deserialize<'de> for GeneratedField {
17092            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17093            where
17094                D: serde::Deserializer<'de>,
17095            {
17096                struct GeneratedVisitor;
17097
17098                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17099                    type Value = GeneratedField;
17100
17101                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17102                        write!(formatter, "expected one of: {:?}", &FIELDS)
17103                    }
17104
17105                    #[allow(unused_variables)]
17106                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17107                    where
17108                        E: serde::de::Error,
17109                    {
17110                            Err(serde::de::Error::unknown_field(value, FIELDS))
17111                    }
17112                }
17113                deserializer.deserialize_identifier(GeneratedVisitor)
17114            }
17115        }
17116        struct GeneratedVisitor;
17117        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17118            type Value = UpdateStreamingJobNodeLabelsResponse;
17119
17120            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17121                formatter.write_str("struct meta.UpdateStreamingJobNodeLabelsResponse")
17122            }
17123
17124            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateStreamingJobNodeLabelsResponse, V::Error>
17125                where
17126                    V: serde::de::MapAccess<'de>,
17127            {
17128                while map_.next_key::<GeneratedField>()?.is_some() {
17129                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
17130                }
17131                Ok(UpdateStreamingJobNodeLabelsResponse {
17132                })
17133            }
17134        }
17135        deserializer.deserialize_struct("meta.UpdateStreamingJobNodeLabelsResponse", FIELDS, GeneratedVisitor)
17136    }
17137}
17138impl serde::Serialize for UpdateWorkerNodeSchedulabilityRequest {
17139    #[allow(deprecated)]
17140    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17141    where
17142        S: serde::Serializer,
17143    {
17144        use serde::ser::SerializeStruct;
17145        let mut len = 0;
17146        if !self.worker_ids.is_empty() {
17147            len += 1;
17148        }
17149        if self.schedulability != 0 {
17150            len += 1;
17151        }
17152        let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", len)?;
17153        if !self.worker_ids.is_empty() {
17154            struct_ser.serialize_field("workerIds", &self.worker_ids)?;
17155        }
17156        if self.schedulability != 0 {
17157            let v = update_worker_node_schedulability_request::Schedulability::try_from(self.schedulability)
17158                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.schedulability)))?;
17159            struct_ser.serialize_field("schedulability", &v)?;
17160        }
17161        struct_ser.end()
17162    }
17163}
17164impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityRequest {
17165    #[allow(deprecated)]
17166    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17167    where
17168        D: serde::Deserializer<'de>,
17169    {
17170        const FIELDS: &[&str] = &[
17171            "worker_ids",
17172            "workerIds",
17173            "schedulability",
17174        ];
17175
17176        #[allow(clippy::enum_variant_names)]
17177        enum GeneratedField {
17178            WorkerIds,
17179            Schedulability,
17180        }
17181        impl<'de> serde::Deserialize<'de> for GeneratedField {
17182            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17183            where
17184                D: serde::Deserializer<'de>,
17185            {
17186                struct GeneratedVisitor;
17187
17188                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17189                    type Value = GeneratedField;
17190
17191                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17192                        write!(formatter, "expected one of: {:?}", &FIELDS)
17193                    }
17194
17195                    #[allow(unused_variables)]
17196                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17197                    where
17198                        E: serde::de::Error,
17199                    {
17200                        match value {
17201                            "workerIds" | "worker_ids" => Ok(GeneratedField::WorkerIds),
17202                            "schedulability" => Ok(GeneratedField::Schedulability),
17203                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17204                        }
17205                    }
17206                }
17207                deserializer.deserialize_identifier(GeneratedVisitor)
17208            }
17209        }
17210        struct GeneratedVisitor;
17211        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17212            type Value = UpdateWorkerNodeSchedulabilityRequest;
17213
17214            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17215                formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityRequest")
17216            }
17217
17218            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityRequest, V::Error>
17219                where
17220                    V: serde::de::MapAccess<'de>,
17221            {
17222                let mut worker_ids__ = None;
17223                let mut schedulability__ = None;
17224                while let Some(k) = map_.next_key()? {
17225                    match k {
17226                        GeneratedField::WorkerIds => {
17227                            if worker_ids__.is_some() {
17228                                return Err(serde::de::Error::duplicate_field("workerIds"));
17229                            }
17230                            worker_ids__ = 
17231                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
17232                                    .into_iter().map(|x| x.0).collect())
17233                            ;
17234                        }
17235                        GeneratedField::Schedulability => {
17236                            if schedulability__.is_some() {
17237                                return Err(serde::de::Error::duplicate_field("schedulability"));
17238                            }
17239                            schedulability__ = Some(map_.next_value::<update_worker_node_schedulability_request::Schedulability>()? as i32);
17240                        }
17241                    }
17242                }
17243                Ok(UpdateWorkerNodeSchedulabilityRequest {
17244                    worker_ids: worker_ids__.unwrap_or_default(),
17245                    schedulability: schedulability__.unwrap_or_default(),
17246                })
17247            }
17248        }
17249        deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityRequest", FIELDS, GeneratedVisitor)
17250    }
17251}
17252impl serde::Serialize for update_worker_node_schedulability_request::Schedulability {
17253    #[allow(deprecated)]
17254    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17255    where
17256        S: serde::Serializer,
17257    {
17258        let variant = match self {
17259            Self::Unspecified => "UNSPECIFIED",
17260            Self::Schedulable => "SCHEDULABLE",
17261            Self::Unschedulable => "UNSCHEDULABLE",
17262        };
17263        serializer.serialize_str(variant)
17264    }
17265}
17266impl<'de> serde::Deserialize<'de> for update_worker_node_schedulability_request::Schedulability {
17267    #[allow(deprecated)]
17268    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17269    where
17270        D: serde::Deserializer<'de>,
17271    {
17272        const FIELDS: &[&str] = &[
17273            "UNSPECIFIED",
17274            "SCHEDULABLE",
17275            "UNSCHEDULABLE",
17276        ];
17277
17278        struct GeneratedVisitor;
17279
17280        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17281            type Value = update_worker_node_schedulability_request::Schedulability;
17282
17283            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17284                write!(formatter, "expected one of: {:?}", &FIELDS)
17285            }
17286
17287            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
17288            where
17289                E: serde::de::Error,
17290            {
17291                i32::try_from(v)
17292                    .ok()
17293                    .and_then(|x| x.try_into().ok())
17294                    .ok_or_else(|| {
17295                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
17296                    })
17297            }
17298
17299            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
17300            where
17301                E: serde::de::Error,
17302            {
17303                i32::try_from(v)
17304                    .ok()
17305                    .and_then(|x| x.try_into().ok())
17306                    .ok_or_else(|| {
17307                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
17308                    })
17309            }
17310
17311            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
17312            where
17313                E: serde::de::Error,
17314            {
17315                match value {
17316                    "UNSPECIFIED" => Ok(update_worker_node_schedulability_request::Schedulability::Unspecified),
17317                    "SCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Schedulable),
17318                    "UNSCHEDULABLE" => Ok(update_worker_node_schedulability_request::Schedulability::Unschedulable),
17319                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
17320                }
17321            }
17322        }
17323        deserializer.deserialize_any(GeneratedVisitor)
17324    }
17325}
17326impl serde::Serialize for UpdateWorkerNodeSchedulabilityResponse {
17327    #[allow(deprecated)]
17328    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17329    where
17330        S: serde::Serializer,
17331    {
17332        use serde::ser::SerializeStruct;
17333        let mut len = 0;
17334        if self.status.is_some() {
17335            len += 1;
17336        }
17337        let mut struct_ser = serializer.serialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", len)?;
17338        if let Some(v) = self.status.as_ref() {
17339            struct_ser.serialize_field("status", v)?;
17340        }
17341        struct_ser.end()
17342    }
17343}
17344impl<'de> serde::Deserialize<'de> for UpdateWorkerNodeSchedulabilityResponse {
17345    #[allow(deprecated)]
17346    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17347    where
17348        D: serde::Deserializer<'de>,
17349    {
17350        const FIELDS: &[&str] = &[
17351            "status",
17352        ];
17353
17354        #[allow(clippy::enum_variant_names)]
17355        enum GeneratedField {
17356            Status,
17357        }
17358        impl<'de> serde::Deserialize<'de> for GeneratedField {
17359            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17360            where
17361                D: serde::Deserializer<'de>,
17362            {
17363                struct GeneratedVisitor;
17364
17365                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17366                    type Value = GeneratedField;
17367
17368                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17369                        write!(formatter, "expected one of: {:?}", &FIELDS)
17370                    }
17371
17372                    #[allow(unused_variables)]
17373                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17374                    where
17375                        E: serde::de::Error,
17376                    {
17377                        match value {
17378                            "status" => Ok(GeneratedField::Status),
17379                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17380                        }
17381                    }
17382                }
17383                deserializer.deserialize_identifier(GeneratedVisitor)
17384            }
17385        }
17386        struct GeneratedVisitor;
17387        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17388            type Value = UpdateWorkerNodeSchedulabilityResponse;
17389
17390            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17391                formatter.write_str("struct meta.UpdateWorkerNodeSchedulabilityResponse")
17392            }
17393
17394            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateWorkerNodeSchedulabilityResponse, V::Error>
17395                where
17396                    V: serde::de::MapAccess<'de>,
17397            {
17398                let mut status__ = None;
17399                while let Some(k) = map_.next_key()? {
17400                    match k {
17401                        GeneratedField::Status => {
17402                            if status__.is_some() {
17403                                return Err(serde::de::Error::duplicate_field("status"));
17404                            }
17405                            status__ = map_.next_value()?;
17406                        }
17407                    }
17408                }
17409                Ok(UpdateWorkerNodeSchedulabilityResponse {
17410                    status: status__,
17411                })
17412            }
17413        }
17414        deserializer.deserialize_struct("meta.UpdateWorkerNodeSchedulabilityResponse", FIELDS, GeneratedVisitor)
17415    }
17416}
17417impl serde::Serialize for WorkerReschedule {
17418    #[allow(deprecated)]
17419    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
17420    where
17421        S: serde::Serializer,
17422    {
17423        use serde::ser::SerializeStruct;
17424        let mut len = 0;
17425        if !self.worker_actor_diff.is_empty() {
17426            len += 1;
17427        }
17428        let mut struct_ser = serializer.serialize_struct("meta.WorkerReschedule", len)?;
17429        if !self.worker_actor_diff.is_empty() {
17430            struct_ser.serialize_field("workerActorDiff", &self.worker_actor_diff)?;
17431        }
17432        struct_ser.end()
17433    }
17434}
17435impl<'de> serde::Deserialize<'de> for WorkerReschedule {
17436    #[allow(deprecated)]
17437    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
17438    where
17439        D: serde::Deserializer<'de>,
17440    {
17441        const FIELDS: &[&str] = &[
17442            "worker_actor_diff",
17443            "workerActorDiff",
17444        ];
17445
17446        #[allow(clippy::enum_variant_names)]
17447        enum GeneratedField {
17448            WorkerActorDiff,
17449        }
17450        impl<'de> serde::Deserialize<'de> for GeneratedField {
17451            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
17452            where
17453                D: serde::Deserializer<'de>,
17454            {
17455                struct GeneratedVisitor;
17456
17457                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17458                    type Value = GeneratedField;
17459
17460                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17461                        write!(formatter, "expected one of: {:?}", &FIELDS)
17462                    }
17463
17464                    #[allow(unused_variables)]
17465                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
17466                    where
17467                        E: serde::de::Error,
17468                    {
17469                        match value {
17470                            "workerActorDiff" | "worker_actor_diff" => Ok(GeneratedField::WorkerActorDiff),
17471                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
17472                        }
17473                    }
17474                }
17475                deserializer.deserialize_identifier(GeneratedVisitor)
17476            }
17477        }
17478        struct GeneratedVisitor;
17479        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
17480            type Value = WorkerReschedule;
17481
17482            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17483                formatter.write_str("struct meta.WorkerReschedule")
17484            }
17485
17486            fn visit_map<V>(self, mut map_: V) -> std::result::Result<WorkerReschedule, V::Error>
17487                where
17488                    V: serde::de::MapAccess<'de>,
17489            {
17490                let mut worker_actor_diff__ = None;
17491                while let Some(k) = map_.next_key()? {
17492                    match k {
17493                        GeneratedField::WorkerActorDiff => {
17494                            if worker_actor_diff__.is_some() {
17495                                return Err(serde::de::Error::duplicate_field("workerActorDiff"));
17496                            }
17497                            worker_actor_diff__ = Some(
17498                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, ::pbjson::private::NumberDeserialize<i32>>>()?
17499                                    .into_iter().map(|(k,v)| (k.0, v.0)).collect()
17500                            );
17501                        }
17502                    }
17503                }
17504                Ok(WorkerReschedule {
17505                    worker_actor_diff: worker_actor_diff__.unwrap_or_default(),
17506                })
17507            }
17508        }
17509        deserializer.deserialize_struct("meta.WorkerReschedule", FIELDS, GeneratedVisitor)
17510    }
17511}