risingwave_pb/
common.serde.rs

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