risingwave_pb/
connector_service.serde.rs

1use crate::connector_service::*;
2impl serde::Serialize for CdcMessage {
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.payload.is_empty() {
11            len += 1;
12        }
13        if !self.partition.is_empty() {
14            len += 1;
15        }
16        if !self.offset.is_empty() {
17            len += 1;
18        }
19        if !self.full_table_name.is_empty() {
20            len += 1;
21        }
22        if self.source_ts_ms != 0 {
23            len += 1;
24        }
25        if self.msg_type != 0 {
26            len += 1;
27        }
28        if !self.key.is_empty() {
29            len += 1;
30        }
31        let mut struct_ser = serializer.serialize_struct("connector_service.CdcMessage", len)?;
32        if !self.payload.is_empty() {
33            struct_ser.serialize_field("payload", &self.payload)?;
34        }
35        if !self.partition.is_empty() {
36            struct_ser.serialize_field("partition", &self.partition)?;
37        }
38        if !self.offset.is_empty() {
39            struct_ser.serialize_field("offset", &self.offset)?;
40        }
41        if !self.full_table_name.is_empty() {
42            struct_ser.serialize_field("fullTableName", &self.full_table_name)?;
43        }
44        if self.source_ts_ms != 0 {
45            #[allow(clippy::needless_borrow)]
46            #[allow(clippy::needless_borrows_for_generic_args)]
47            struct_ser.serialize_field("sourceTsMs", ToString::to_string(&self.source_ts_ms).as_str())?;
48        }
49        if self.msg_type != 0 {
50            let v = cdc_message::CdcMessageType::try_from(self.msg_type)
51                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.msg_type)))?;
52            struct_ser.serialize_field("msgType", &v)?;
53        }
54        if !self.key.is_empty() {
55            struct_ser.serialize_field("key", &self.key)?;
56        }
57        struct_ser.end()
58    }
59}
60impl<'de> serde::Deserialize<'de> for CdcMessage {
61    #[allow(deprecated)]
62    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
63    where
64        D: serde::Deserializer<'de>,
65    {
66        const FIELDS: &[&str] = &[
67            "payload",
68            "partition",
69            "offset",
70            "full_table_name",
71            "fullTableName",
72            "source_ts_ms",
73            "sourceTsMs",
74            "msg_type",
75            "msgType",
76            "key",
77        ];
78
79        #[allow(clippy::enum_variant_names)]
80        enum GeneratedField {
81            Payload,
82            Partition,
83            Offset,
84            FullTableName,
85            SourceTsMs,
86            MsgType,
87            Key,
88        }
89        impl<'de> serde::Deserialize<'de> for GeneratedField {
90            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
91            where
92                D: serde::Deserializer<'de>,
93            {
94                struct GeneratedVisitor;
95
96                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
97                    type Value = GeneratedField;
98
99                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
100                        write!(formatter, "expected one of: {:?}", &FIELDS)
101                    }
102
103                    #[allow(unused_variables)]
104                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
105                    where
106                        E: serde::de::Error,
107                    {
108                        match value {
109                            "payload" => Ok(GeneratedField::Payload),
110                            "partition" => Ok(GeneratedField::Partition),
111                            "offset" => Ok(GeneratedField::Offset),
112                            "fullTableName" | "full_table_name" => Ok(GeneratedField::FullTableName),
113                            "sourceTsMs" | "source_ts_ms" => Ok(GeneratedField::SourceTsMs),
114                            "msgType" | "msg_type" => Ok(GeneratedField::MsgType),
115                            "key" => Ok(GeneratedField::Key),
116                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
117                        }
118                    }
119                }
120                deserializer.deserialize_identifier(GeneratedVisitor)
121            }
122        }
123        struct GeneratedVisitor;
124        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
125            type Value = CdcMessage;
126
127            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
128                formatter.write_str("struct connector_service.CdcMessage")
129            }
130
131            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcMessage, V::Error>
132                where
133                    V: serde::de::MapAccess<'de>,
134            {
135                let mut payload__ = None;
136                let mut partition__ = None;
137                let mut offset__ = None;
138                let mut full_table_name__ = None;
139                let mut source_ts_ms__ = None;
140                let mut msg_type__ = None;
141                let mut key__ = None;
142                while let Some(k) = map_.next_key()? {
143                    match k {
144                        GeneratedField::Payload => {
145                            if payload__.is_some() {
146                                return Err(serde::de::Error::duplicate_field("payload"));
147                            }
148                            payload__ = Some(map_.next_value()?);
149                        }
150                        GeneratedField::Partition => {
151                            if partition__.is_some() {
152                                return Err(serde::de::Error::duplicate_field("partition"));
153                            }
154                            partition__ = Some(map_.next_value()?);
155                        }
156                        GeneratedField::Offset => {
157                            if offset__.is_some() {
158                                return Err(serde::de::Error::duplicate_field("offset"));
159                            }
160                            offset__ = Some(map_.next_value()?);
161                        }
162                        GeneratedField::FullTableName => {
163                            if full_table_name__.is_some() {
164                                return Err(serde::de::Error::duplicate_field("fullTableName"));
165                            }
166                            full_table_name__ = Some(map_.next_value()?);
167                        }
168                        GeneratedField::SourceTsMs => {
169                            if source_ts_ms__.is_some() {
170                                return Err(serde::de::Error::duplicate_field("sourceTsMs"));
171                            }
172                            source_ts_ms__ = 
173                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
174                            ;
175                        }
176                        GeneratedField::MsgType => {
177                            if msg_type__.is_some() {
178                                return Err(serde::de::Error::duplicate_field("msgType"));
179                            }
180                            msg_type__ = Some(map_.next_value::<cdc_message::CdcMessageType>()? as i32);
181                        }
182                        GeneratedField::Key => {
183                            if key__.is_some() {
184                                return Err(serde::de::Error::duplicate_field("key"));
185                            }
186                            key__ = Some(map_.next_value()?);
187                        }
188                    }
189                }
190                Ok(CdcMessage {
191                    payload: payload__.unwrap_or_default(),
192                    partition: partition__.unwrap_or_default(),
193                    offset: offset__.unwrap_or_default(),
194                    full_table_name: full_table_name__.unwrap_or_default(),
195                    source_ts_ms: source_ts_ms__.unwrap_or_default(),
196                    msg_type: msg_type__.unwrap_or_default(),
197                    key: key__.unwrap_or_default(),
198                })
199            }
200        }
201        deserializer.deserialize_struct("connector_service.CdcMessage", FIELDS, GeneratedVisitor)
202    }
203}
204impl serde::Serialize for cdc_message::CdcMessageType {
205    #[allow(deprecated)]
206    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
207    where
208        S: serde::Serializer,
209    {
210        let variant = match self {
211            Self::Unspecified => "UNSPECIFIED",
212            Self::Heartbeat => "HEARTBEAT",
213            Self::Data => "DATA",
214            Self::TransactionMeta => "TRANSACTION_META",
215            Self::SchemaChange => "SCHEMA_CHANGE",
216        };
217        serializer.serialize_str(variant)
218    }
219}
220impl<'de> serde::Deserialize<'de> for cdc_message::CdcMessageType {
221    #[allow(deprecated)]
222    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
223    where
224        D: serde::Deserializer<'de>,
225    {
226        const FIELDS: &[&str] = &[
227            "UNSPECIFIED",
228            "HEARTBEAT",
229            "DATA",
230            "TRANSACTION_META",
231            "SCHEMA_CHANGE",
232        ];
233
234        struct GeneratedVisitor;
235
236        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
237            type Value = cdc_message::CdcMessageType;
238
239            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
240                write!(formatter, "expected one of: {:?}", &FIELDS)
241            }
242
243            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
244            where
245                E: serde::de::Error,
246            {
247                i32::try_from(v)
248                    .ok()
249                    .and_then(|x| x.try_into().ok())
250                    .ok_or_else(|| {
251                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
252                    })
253            }
254
255            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
256            where
257                E: serde::de::Error,
258            {
259                i32::try_from(v)
260                    .ok()
261                    .and_then(|x| x.try_into().ok())
262                    .ok_or_else(|| {
263                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
264                    })
265            }
266
267            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
268            where
269                E: serde::de::Error,
270            {
271                match value {
272                    "UNSPECIFIED" => Ok(cdc_message::CdcMessageType::Unspecified),
273                    "HEARTBEAT" => Ok(cdc_message::CdcMessageType::Heartbeat),
274                    "DATA" => Ok(cdc_message::CdcMessageType::Data),
275                    "TRANSACTION_META" => Ok(cdc_message::CdcMessageType::TransactionMeta),
276                    "SCHEMA_CHANGE" => Ok(cdc_message::CdcMessageType::SchemaChange),
277                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
278                }
279            }
280        }
281        deserializer.deserialize_any(GeneratedVisitor)
282    }
283}
284impl serde::Serialize for CoordinateRequest {
285    #[allow(deprecated)]
286    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
287    where
288        S: serde::Serializer,
289    {
290        use serde::ser::SerializeStruct;
291        let mut len = 0;
292        if self.msg.is_some() {
293            len += 1;
294        }
295        let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateRequest", len)?;
296        if let Some(v) = self.msg.as_ref() {
297            match v {
298                coordinate_request::Msg::StartRequest(v) => {
299                    struct_ser.serialize_field("startRequest", v)?;
300                }
301                coordinate_request::Msg::CommitRequest(v) => {
302                    struct_ser.serialize_field("commitRequest", v)?;
303                }
304                coordinate_request::Msg::UpdateVnodeRequest(v) => {
305                    struct_ser.serialize_field("updateVnodeRequest", v)?;
306                }
307                coordinate_request::Msg::Stop(v) => {
308                    struct_ser.serialize_field("stop", v)?;
309                }
310                coordinate_request::Msg::AlignInitialEpochRequest(v) => {
311                    #[allow(clippy::needless_borrow)]
312                    #[allow(clippy::needless_borrows_for_generic_args)]
313                    struct_ser.serialize_field("alignInitialEpochRequest", ToString::to_string(&v).as_str())?;
314                }
315            }
316        }
317        struct_ser.end()
318    }
319}
320impl<'de> serde::Deserialize<'de> for CoordinateRequest {
321    #[allow(deprecated)]
322    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
323    where
324        D: serde::Deserializer<'de>,
325    {
326        const FIELDS: &[&str] = &[
327            "start_request",
328            "startRequest",
329            "commit_request",
330            "commitRequest",
331            "update_vnode_request",
332            "updateVnodeRequest",
333            "stop",
334            "align_initial_epoch_request",
335            "alignInitialEpochRequest",
336        ];
337
338        #[allow(clippy::enum_variant_names)]
339        enum GeneratedField {
340            StartRequest,
341            CommitRequest,
342            UpdateVnodeRequest,
343            Stop,
344            AlignInitialEpochRequest,
345        }
346        impl<'de> serde::Deserialize<'de> for GeneratedField {
347            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
348            where
349                D: serde::Deserializer<'de>,
350            {
351                struct GeneratedVisitor;
352
353                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
354                    type Value = GeneratedField;
355
356                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
357                        write!(formatter, "expected one of: {:?}", &FIELDS)
358                    }
359
360                    #[allow(unused_variables)]
361                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
362                    where
363                        E: serde::de::Error,
364                    {
365                        match value {
366                            "startRequest" | "start_request" => Ok(GeneratedField::StartRequest),
367                            "commitRequest" | "commit_request" => Ok(GeneratedField::CommitRequest),
368                            "updateVnodeRequest" | "update_vnode_request" => Ok(GeneratedField::UpdateVnodeRequest),
369                            "stop" => Ok(GeneratedField::Stop),
370                            "alignInitialEpochRequest" | "align_initial_epoch_request" => Ok(GeneratedField::AlignInitialEpochRequest),
371                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
372                        }
373                    }
374                }
375                deserializer.deserialize_identifier(GeneratedVisitor)
376            }
377        }
378        struct GeneratedVisitor;
379        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
380            type Value = CoordinateRequest;
381
382            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
383                formatter.write_str("struct connector_service.CoordinateRequest")
384            }
385
386            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CoordinateRequest, V::Error>
387                where
388                    V: serde::de::MapAccess<'de>,
389            {
390                let mut msg__ = None;
391                while let Some(k) = map_.next_key()? {
392                    match k {
393                        GeneratedField::StartRequest => {
394                            if msg__.is_some() {
395                                return Err(serde::de::Error::duplicate_field("startRequest"));
396                            }
397                            msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_request::Msg::StartRequest)
398;
399                        }
400                        GeneratedField::CommitRequest => {
401                            if msg__.is_some() {
402                                return Err(serde::de::Error::duplicate_field("commitRequest"));
403                            }
404                            msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_request::Msg::CommitRequest)
405;
406                        }
407                        GeneratedField::UpdateVnodeRequest => {
408                            if msg__.is_some() {
409                                return Err(serde::de::Error::duplicate_field("updateVnodeRequest"));
410                            }
411                            msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_request::Msg::UpdateVnodeRequest)
412;
413                        }
414                        GeneratedField::Stop => {
415                            if msg__.is_some() {
416                                return Err(serde::de::Error::duplicate_field("stop"));
417                            }
418                            msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_request::Msg::Stop);
419                        }
420                        GeneratedField::AlignInitialEpochRequest => {
421                            if msg__.is_some() {
422                                return Err(serde::de::Error::duplicate_field("alignInitialEpochRequest"));
423                            }
424                            msg__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| coordinate_request::Msg::AlignInitialEpochRequest(x.0));
425                        }
426                    }
427                }
428                Ok(CoordinateRequest {
429                    msg: msg__,
430                })
431            }
432        }
433        deserializer.deserialize_struct("connector_service.CoordinateRequest", FIELDS, GeneratedVisitor)
434    }
435}
436impl serde::Serialize for coordinate_request::CommitRequest {
437    #[allow(deprecated)]
438    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
439    where
440        S: serde::Serializer,
441    {
442        use serde::ser::SerializeStruct;
443        let mut len = 0;
444        if self.epoch != 0 {
445            len += 1;
446        }
447        if self.metadata.is_some() {
448            len += 1;
449        }
450        if self.add_columns.is_some() {
451            len += 1;
452        }
453        let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateRequest.CommitRequest", len)?;
454        if self.epoch != 0 {
455            #[allow(clippy::needless_borrow)]
456            #[allow(clippy::needless_borrows_for_generic_args)]
457            struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
458        }
459        if let Some(v) = self.metadata.as_ref() {
460            struct_ser.serialize_field("metadata", v)?;
461        }
462        if let Some(v) = self.add_columns.as_ref() {
463            struct_ser.serialize_field("addColumns", v)?;
464        }
465        struct_ser.end()
466    }
467}
468impl<'de> serde::Deserialize<'de> for coordinate_request::CommitRequest {
469    #[allow(deprecated)]
470    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
471    where
472        D: serde::Deserializer<'de>,
473    {
474        const FIELDS: &[&str] = &[
475            "epoch",
476            "metadata",
477            "add_columns",
478            "addColumns",
479        ];
480
481        #[allow(clippy::enum_variant_names)]
482        enum GeneratedField {
483            Epoch,
484            Metadata,
485            AddColumns,
486        }
487        impl<'de> serde::Deserialize<'de> for GeneratedField {
488            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
489            where
490                D: serde::Deserializer<'de>,
491            {
492                struct GeneratedVisitor;
493
494                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
495                    type Value = GeneratedField;
496
497                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
498                        write!(formatter, "expected one of: {:?}", &FIELDS)
499                    }
500
501                    #[allow(unused_variables)]
502                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
503                    where
504                        E: serde::de::Error,
505                    {
506                        match value {
507                            "epoch" => Ok(GeneratedField::Epoch),
508                            "metadata" => Ok(GeneratedField::Metadata),
509                            "addColumns" | "add_columns" => Ok(GeneratedField::AddColumns),
510                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
511                        }
512                    }
513                }
514                deserializer.deserialize_identifier(GeneratedVisitor)
515            }
516        }
517        struct GeneratedVisitor;
518        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
519            type Value = coordinate_request::CommitRequest;
520
521            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
522                formatter.write_str("struct connector_service.CoordinateRequest.CommitRequest")
523            }
524
525            fn visit_map<V>(self, mut map_: V) -> std::result::Result<coordinate_request::CommitRequest, V::Error>
526                where
527                    V: serde::de::MapAccess<'de>,
528            {
529                let mut epoch__ = None;
530                let mut metadata__ = None;
531                let mut add_columns__ = None;
532                while let Some(k) = map_.next_key()? {
533                    match k {
534                        GeneratedField::Epoch => {
535                            if epoch__.is_some() {
536                                return Err(serde::de::Error::duplicate_field("epoch"));
537                            }
538                            epoch__ = 
539                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
540                            ;
541                        }
542                        GeneratedField::Metadata => {
543                            if metadata__.is_some() {
544                                return Err(serde::de::Error::duplicate_field("metadata"));
545                            }
546                            metadata__ = map_.next_value()?;
547                        }
548                        GeneratedField::AddColumns => {
549                            if add_columns__.is_some() {
550                                return Err(serde::de::Error::duplicate_field("addColumns"));
551                            }
552                            add_columns__ = map_.next_value()?;
553                        }
554                    }
555                }
556                Ok(coordinate_request::CommitRequest {
557                    epoch: epoch__.unwrap_or_default(),
558                    metadata: metadata__,
559                    add_columns: add_columns__,
560                })
561            }
562        }
563        deserializer.deserialize_struct("connector_service.CoordinateRequest.CommitRequest", FIELDS, GeneratedVisitor)
564    }
565}
566impl serde::Serialize for coordinate_request::StartCoordinationRequest {
567    #[allow(deprecated)]
568    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
569    where
570        S: serde::Serializer,
571    {
572        use serde::ser::SerializeStruct;
573        let mut len = 0;
574        if self.vnode_bitmap.is_some() {
575            len += 1;
576        }
577        if self.param.is_some() {
578            len += 1;
579        }
580        let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateRequest.StartCoordinationRequest", len)?;
581        if let Some(v) = self.vnode_bitmap.as_ref() {
582            struct_ser.serialize_field("vnodeBitmap", v)?;
583        }
584        if let Some(v) = self.param.as_ref() {
585            struct_ser.serialize_field("param", v)?;
586        }
587        struct_ser.end()
588    }
589}
590impl<'de> serde::Deserialize<'de> for coordinate_request::StartCoordinationRequest {
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            "vnode_bitmap",
598            "vnodeBitmap",
599            "param",
600        ];
601
602        #[allow(clippy::enum_variant_names)]
603        enum GeneratedField {
604            VnodeBitmap,
605            Param,
606        }
607        impl<'de> serde::Deserialize<'de> for GeneratedField {
608            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
609            where
610                D: serde::Deserializer<'de>,
611            {
612                struct GeneratedVisitor;
613
614                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
615                    type Value = GeneratedField;
616
617                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
618                        write!(formatter, "expected one of: {:?}", &FIELDS)
619                    }
620
621                    #[allow(unused_variables)]
622                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
623                    where
624                        E: serde::de::Error,
625                    {
626                        match value {
627                            "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
628                            "param" => Ok(GeneratedField::Param),
629                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
630                        }
631                    }
632                }
633                deserializer.deserialize_identifier(GeneratedVisitor)
634            }
635        }
636        struct GeneratedVisitor;
637        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
638            type Value = coordinate_request::StartCoordinationRequest;
639
640            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
641                formatter.write_str("struct connector_service.CoordinateRequest.StartCoordinationRequest")
642            }
643
644            fn visit_map<V>(self, mut map_: V) -> std::result::Result<coordinate_request::StartCoordinationRequest, V::Error>
645                where
646                    V: serde::de::MapAccess<'de>,
647            {
648                let mut vnode_bitmap__ = None;
649                let mut param__ = None;
650                while let Some(k) = map_.next_key()? {
651                    match k {
652                        GeneratedField::VnodeBitmap => {
653                            if vnode_bitmap__.is_some() {
654                                return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
655                            }
656                            vnode_bitmap__ = map_.next_value()?;
657                        }
658                        GeneratedField::Param => {
659                            if param__.is_some() {
660                                return Err(serde::de::Error::duplicate_field("param"));
661                            }
662                            param__ = map_.next_value()?;
663                        }
664                    }
665                }
666                Ok(coordinate_request::StartCoordinationRequest {
667                    vnode_bitmap: vnode_bitmap__,
668                    param: param__,
669                })
670            }
671        }
672        deserializer.deserialize_struct("connector_service.CoordinateRequest.StartCoordinationRequest", FIELDS, GeneratedVisitor)
673    }
674}
675impl serde::Serialize for coordinate_request::UpdateVnodeBitmapRequest {
676    #[allow(deprecated)]
677    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
678    where
679        S: serde::Serializer,
680    {
681        use serde::ser::SerializeStruct;
682        let mut len = 0;
683        if self.vnode_bitmap.is_some() {
684            len += 1;
685        }
686        let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateRequest.UpdateVnodeBitmapRequest", len)?;
687        if let Some(v) = self.vnode_bitmap.as_ref() {
688            struct_ser.serialize_field("vnodeBitmap", v)?;
689        }
690        struct_ser.end()
691    }
692}
693impl<'de> serde::Deserialize<'de> for coordinate_request::UpdateVnodeBitmapRequest {
694    #[allow(deprecated)]
695    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
696    where
697        D: serde::Deserializer<'de>,
698    {
699        const FIELDS: &[&str] = &[
700            "vnode_bitmap",
701            "vnodeBitmap",
702        ];
703
704        #[allow(clippy::enum_variant_names)]
705        enum GeneratedField {
706            VnodeBitmap,
707        }
708        impl<'de> serde::Deserialize<'de> for GeneratedField {
709            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
710            where
711                D: serde::Deserializer<'de>,
712            {
713                struct GeneratedVisitor;
714
715                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
716                    type Value = GeneratedField;
717
718                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
719                        write!(formatter, "expected one of: {:?}", &FIELDS)
720                    }
721
722                    #[allow(unused_variables)]
723                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
724                    where
725                        E: serde::de::Error,
726                    {
727                        match value {
728                            "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
729                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
730                        }
731                    }
732                }
733                deserializer.deserialize_identifier(GeneratedVisitor)
734            }
735        }
736        struct GeneratedVisitor;
737        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
738            type Value = coordinate_request::UpdateVnodeBitmapRequest;
739
740            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
741                formatter.write_str("struct connector_service.CoordinateRequest.UpdateVnodeBitmapRequest")
742            }
743
744            fn visit_map<V>(self, mut map_: V) -> std::result::Result<coordinate_request::UpdateVnodeBitmapRequest, V::Error>
745                where
746                    V: serde::de::MapAccess<'de>,
747            {
748                let mut vnode_bitmap__ = None;
749                while let Some(k) = map_.next_key()? {
750                    match k {
751                        GeneratedField::VnodeBitmap => {
752                            if vnode_bitmap__.is_some() {
753                                return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
754                            }
755                            vnode_bitmap__ = map_.next_value()?;
756                        }
757                    }
758                }
759                Ok(coordinate_request::UpdateVnodeBitmapRequest {
760                    vnode_bitmap: vnode_bitmap__,
761                })
762            }
763        }
764        deserializer.deserialize_struct("connector_service.CoordinateRequest.UpdateVnodeBitmapRequest", FIELDS, GeneratedVisitor)
765    }
766}
767impl serde::Serialize for CoordinateResponse {
768    #[allow(deprecated)]
769    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
770    where
771        S: serde::Serializer,
772    {
773        use serde::ser::SerializeStruct;
774        let mut len = 0;
775        if self.msg.is_some() {
776            len += 1;
777        }
778        let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateResponse", len)?;
779        if let Some(v) = self.msg.as_ref() {
780            match v {
781                coordinate_response::Msg::StartResponse(v) => {
782                    struct_ser.serialize_field("startResponse", v)?;
783                }
784                coordinate_response::Msg::CommitResponse(v) => {
785                    struct_ser.serialize_field("commitResponse", v)?;
786                }
787                coordinate_response::Msg::Stopped(v) => {
788                    struct_ser.serialize_field("stopped", v)?;
789                }
790                coordinate_response::Msg::AlignInitialEpochResponse(v) => {
791                    #[allow(clippy::needless_borrow)]
792                    #[allow(clippy::needless_borrows_for_generic_args)]
793                    struct_ser.serialize_field("alignInitialEpochResponse", ToString::to_string(&v).as_str())?;
794                }
795            }
796        }
797        struct_ser.end()
798    }
799}
800impl<'de> serde::Deserialize<'de> for CoordinateResponse {
801    #[allow(deprecated)]
802    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
803    where
804        D: serde::Deserializer<'de>,
805    {
806        const FIELDS: &[&str] = &[
807            "start_response",
808            "startResponse",
809            "commit_response",
810            "commitResponse",
811            "stopped",
812            "align_initial_epoch_response",
813            "alignInitialEpochResponse",
814        ];
815
816        #[allow(clippy::enum_variant_names)]
817        enum GeneratedField {
818            StartResponse,
819            CommitResponse,
820            Stopped,
821            AlignInitialEpochResponse,
822        }
823        impl<'de> serde::Deserialize<'de> for GeneratedField {
824            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
825            where
826                D: serde::Deserializer<'de>,
827            {
828                struct GeneratedVisitor;
829
830                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
831                    type Value = GeneratedField;
832
833                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
834                        write!(formatter, "expected one of: {:?}", &FIELDS)
835                    }
836
837                    #[allow(unused_variables)]
838                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
839                    where
840                        E: serde::de::Error,
841                    {
842                        match value {
843                            "startResponse" | "start_response" => Ok(GeneratedField::StartResponse),
844                            "commitResponse" | "commit_response" => Ok(GeneratedField::CommitResponse),
845                            "stopped" => Ok(GeneratedField::Stopped),
846                            "alignInitialEpochResponse" | "align_initial_epoch_response" => Ok(GeneratedField::AlignInitialEpochResponse),
847                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
848                        }
849                    }
850                }
851                deserializer.deserialize_identifier(GeneratedVisitor)
852            }
853        }
854        struct GeneratedVisitor;
855        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
856            type Value = CoordinateResponse;
857
858            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
859                formatter.write_str("struct connector_service.CoordinateResponse")
860            }
861
862            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CoordinateResponse, V::Error>
863                where
864                    V: serde::de::MapAccess<'de>,
865            {
866                let mut msg__ = None;
867                while let Some(k) = map_.next_key()? {
868                    match k {
869                        GeneratedField::StartResponse => {
870                            if msg__.is_some() {
871                                return Err(serde::de::Error::duplicate_field("startResponse"));
872                            }
873                            msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_response::Msg::StartResponse)
874;
875                        }
876                        GeneratedField::CommitResponse => {
877                            if msg__.is_some() {
878                                return Err(serde::de::Error::duplicate_field("commitResponse"));
879                            }
880                            msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_response::Msg::CommitResponse)
881;
882                        }
883                        GeneratedField::Stopped => {
884                            if msg__.is_some() {
885                                return Err(serde::de::Error::duplicate_field("stopped"));
886                            }
887                            msg__ = map_.next_value::<::std::option::Option<_>>()?.map(coordinate_response::Msg::Stopped);
888                        }
889                        GeneratedField::AlignInitialEpochResponse => {
890                            if msg__.is_some() {
891                                return Err(serde::de::Error::duplicate_field("alignInitialEpochResponse"));
892                            }
893                            msg__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| coordinate_response::Msg::AlignInitialEpochResponse(x.0));
894                        }
895                    }
896                }
897                Ok(CoordinateResponse {
898                    msg: msg__,
899                })
900            }
901        }
902        deserializer.deserialize_struct("connector_service.CoordinateResponse", FIELDS, GeneratedVisitor)
903    }
904}
905impl serde::Serialize for coordinate_response::CommitResponse {
906    #[allow(deprecated)]
907    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
908    where
909        S: serde::Serializer,
910    {
911        use serde::ser::SerializeStruct;
912        let mut len = 0;
913        if self.epoch != 0 {
914            len += 1;
915        }
916        let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateResponse.CommitResponse", len)?;
917        if self.epoch != 0 {
918            #[allow(clippy::needless_borrow)]
919            #[allow(clippy::needless_borrows_for_generic_args)]
920            struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
921        }
922        struct_ser.end()
923    }
924}
925impl<'de> serde::Deserialize<'de> for coordinate_response::CommitResponse {
926    #[allow(deprecated)]
927    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
928    where
929        D: serde::Deserializer<'de>,
930    {
931        const FIELDS: &[&str] = &[
932            "epoch",
933        ];
934
935        #[allow(clippy::enum_variant_names)]
936        enum GeneratedField {
937            Epoch,
938        }
939        impl<'de> serde::Deserialize<'de> for GeneratedField {
940            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
941            where
942                D: serde::Deserializer<'de>,
943            {
944                struct GeneratedVisitor;
945
946                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
947                    type Value = GeneratedField;
948
949                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
950                        write!(formatter, "expected one of: {:?}", &FIELDS)
951                    }
952
953                    #[allow(unused_variables)]
954                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
955                    where
956                        E: serde::de::Error,
957                    {
958                        match value {
959                            "epoch" => Ok(GeneratedField::Epoch),
960                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
961                        }
962                    }
963                }
964                deserializer.deserialize_identifier(GeneratedVisitor)
965            }
966        }
967        struct GeneratedVisitor;
968        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
969            type Value = coordinate_response::CommitResponse;
970
971            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
972                formatter.write_str("struct connector_service.CoordinateResponse.CommitResponse")
973            }
974
975            fn visit_map<V>(self, mut map_: V) -> std::result::Result<coordinate_response::CommitResponse, V::Error>
976                where
977                    V: serde::de::MapAccess<'de>,
978            {
979                let mut epoch__ = None;
980                while let Some(k) = map_.next_key()? {
981                    match k {
982                        GeneratedField::Epoch => {
983                            if epoch__.is_some() {
984                                return Err(serde::de::Error::duplicate_field("epoch"));
985                            }
986                            epoch__ = 
987                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
988                            ;
989                        }
990                    }
991                }
992                Ok(coordinate_response::CommitResponse {
993                    epoch: epoch__.unwrap_or_default(),
994                })
995            }
996        }
997        deserializer.deserialize_struct("connector_service.CoordinateResponse.CommitResponse", FIELDS, GeneratedVisitor)
998    }
999}
1000impl serde::Serialize for coordinate_response::StartCoordinationResponse {
1001    #[allow(deprecated)]
1002    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1003    where
1004        S: serde::Serializer,
1005    {
1006        use serde::ser::SerializeStruct;
1007        let mut len = 0;
1008        if self.log_store_rewind_start_epoch.is_some() {
1009            len += 1;
1010        }
1011        let mut struct_ser = serializer.serialize_struct("connector_service.CoordinateResponse.StartCoordinationResponse", len)?;
1012        if let Some(v) = self.log_store_rewind_start_epoch.as_ref() {
1013            #[allow(clippy::needless_borrow)]
1014            #[allow(clippy::needless_borrows_for_generic_args)]
1015            struct_ser.serialize_field("logStoreRewindStartEpoch", ToString::to_string(&v).as_str())?;
1016        }
1017        struct_ser.end()
1018    }
1019}
1020impl<'de> serde::Deserialize<'de> for coordinate_response::StartCoordinationResponse {
1021    #[allow(deprecated)]
1022    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1023    where
1024        D: serde::Deserializer<'de>,
1025    {
1026        const FIELDS: &[&str] = &[
1027            "log_store_rewind_start_epoch",
1028            "logStoreRewindStartEpoch",
1029        ];
1030
1031        #[allow(clippy::enum_variant_names)]
1032        enum GeneratedField {
1033            LogStoreRewindStartEpoch,
1034        }
1035        impl<'de> serde::Deserialize<'de> for GeneratedField {
1036            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1037            where
1038                D: serde::Deserializer<'de>,
1039            {
1040                struct GeneratedVisitor;
1041
1042                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1043                    type Value = GeneratedField;
1044
1045                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1046                        write!(formatter, "expected one of: {:?}", &FIELDS)
1047                    }
1048
1049                    #[allow(unused_variables)]
1050                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1051                    where
1052                        E: serde::de::Error,
1053                    {
1054                        match value {
1055                            "logStoreRewindStartEpoch" | "log_store_rewind_start_epoch" => Ok(GeneratedField::LogStoreRewindStartEpoch),
1056                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1057                        }
1058                    }
1059                }
1060                deserializer.deserialize_identifier(GeneratedVisitor)
1061            }
1062        }
1063        struct GeneratedVisitor;
1064        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1065            type Value = coordinate_response::StartCoordinationResponse;
1066
1067            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1068                formatter.write_str("struct connector_service.CoordinateResponse.StartCoordinationResponse")
1069            }
1070
1071            fn visit_map<V>(self, mut map_: V) -> std::result::Result<coordinate_response::StartCoordinationResponse, V::Error>
1072                where
1073                    V: serde::de::MapAccess<'de>,
1074            {
1075                let mut log_store_rewind_start_epoch__ = None;
1076                while let Some(k) = map_.next_key()? {
1077                    match k {
1078                        GeneratedField::LogStoreRewindStartEpoch => {
1079                            if log_store_rewind_start_epoch__.is_some() {
1080                                return Err(serde::de::Error::duplicate_field("logStoreRewindStartEpoch"));
1081                            }
1082                            log_store_rewind_start_epoch__ = 
1083                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
1084                            ;
1085                        }
1086                    }
1087                }
1088                Ok(coordinate_response::StartCoordinationResponse {
1089                    log_store_rewind_start_epoch: log_store_rewind_start_epoch__,
1090                })
1091            }
1092        }
1093        deserializer.deserialize_struct("connector_service.CoordinateResponse.StartCoordinationResponse", FIELDS, GeneratedVisitor)
1094    }
1095}
1096impl serde::Serialize for GetEventStreamRequest {
1097    #[allow(deprecated)]
1098    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1099    where
1100        S: serde::Serializer,
1101    {
1102        use serde::ser::SerializeStruct;
1103        let mut len = 0;
1104        if self.source_id != 0 {
1105            len += 1;
1106        }
1107        if self.source_type != 0 {
1108            len += 1;
1109        }
1110        if !self.start_offset.is_empty() {
1111            len += 1;
1112        }
1113        if !self.properties.is_empty() {
1114            len += 1;
1115        }
1116        if self.snapshot_done {
1117            len += 1;
1118        }
1119        if self.is_source_job {
1120            len += 1;
1121        }
1122        let mut struct_ser = serializer.serialize_struct("connector_service.GetEventStreamRequest", len)?;
1123        if self.source_id != 0 {
1124            #[allow(clippy::needless_borrow)]
1125            #[allow(clippy::needless_borrows_for_generic_args)]
1126            struct_ser.serialize_field("sourceId", ToString::to_string(&self.source_id).as_str())?;
1127        }
1128        if self.source_type != 0 {
1129            let v = SourceType::try_from(self.source_type)
1130                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.source_type)))?;
1131            struct_ser.serialize_field("sourceType", &v)?;
1132        }
1133        if !self.start_offset.is_empty() {
1134            struct_ser.serialize_field("startOffset", &self.start_offset)?;
1135        }
1136        if !self.properties.is_empty() {
1137            struct_ser.serialize_field("properties", &self.properties)?;
1138        }
1139        if self.snapshot_done {
1140            struct_ser.serialize_field("snapshotDone", &self.snapshot_done)?;
1141        }
1142        if self.is_source_job {
1143            struct_ser.serialize_field("isSourceJob", &self.is_source_job)?;
1144        }
1145        struct_ser.end()
1146    }
1147}
1148impl<'de> serde::Deserialize<'de> for GetEventStreamRequest {
1149    #[allow(deprecated)]
1150    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1151    where
1152        D: serde::Deserializer<'de>,
1153    {
1154        const FIELDS: &[&str] = &[
1155            "source_id",
1156            "sourceId",
1157            "source_type",
1158            "sourceType",
1159            "start_offset",
1160            "startOffset",
1161            "properties",
1162            "snapshot_done",
1163            "snapshotDone",
1164            "is_source_job",
1165            "isSourceJob",
1166        ];
1167
1168        #[allow(clippy::enum_variant_names)]
1169        enum GeneratedField {
1170            SourceId,
1171            SourceType,
1172            StartOffset,
1173            Properties,
1174            SnapshotDone,
1175            IsSourceJob,
1176        }
1177        impl<'de> serde::Deserialize<'de> for GeneratedField {
1178            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1179            where
1180                D: serde::Deserializer<'de>,
1181            {
1182                struct GeneratedVisitor;
1183
1184                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1185                    type Value = GeneratedField;
1186
1187                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1188                        write!(formatter, "expected one of: {:?}", &FIELDS)
1189                    }
1190
1191                    #[allow(unused_variables)]
1192                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1193                    where
1194                        E: serde::de::Error,
1195                    {
1196                        match value {
1197                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1198                            "sourceType" | "source_type" => Ok(GeneratedField::SourceType),
1199                            "startOffset" | "start_offset" => Ok(GeneratedField::StartOffset),
1200                            "properties" => Ok(GeneratedField::Properties),
1201                            "snapshotDone" | "snapshot_done" => Ok(GeneratedField::SnapshotDone),
1202                            "isSourceJob" | "is_source_job" => Ok(GeneratedField::IsSourceJob),
1203                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1204                        }
1205                    }
1206                }
1207                deserializer.deserialize_identifier(GeneratedVisitor)
1208            }
1209        }
1210        struct GeneratedVisitor;
1211        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1212            type Value = GetEventStreamRequest;
1213
1214            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1215                formatter.write_str("struct connector_service.GetEventStreamRequest")
1216            }
1217
1218            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetEventStreamRequest, V::Error>
1219                where
1220                    V: serde::de::MapAccess<'de>,
1221            {
1222                let mut source_id__ = None;
1223                let mut source_type__ = None;
1224                let mut start_offset__ = None;
1225                let mut properties__ = None;
1226                let mut snapshot_done__ = None;
1227                let mut is_source_job__ = None;
1228                while let Some(k) = map_.next_key()? {
1229                    match k {
1230                        GeneratedField::SourceId => {
1231                            if source_id__.is_some() {
1232                                return Err(serde::de::Error::duplicate_field("sourceId"));
1233                            }
1234                            source_id__ = 
1235                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1236                            ;
1237                        }
1238                        GeneratedField::SourceType => {
1239                            if source_type__.is_some() {
1240                                return Err(serde::de::Error::duplicate_field("sourceType"));
1241                            }
1242                            source_type__ = Some(map_.next_value::<SourceType>()? as i32);
1243                        }
1244                        GeneratedField::StartOffset => {
1245                            if start_offset__.is_some() {
1246                                return Err(serde::de::Error::duplicate_field("startOffset"));
1247                            }
1248                            start_offset__ = Some(map_.next_value()?);
1249                        }
1250                        GeneratedField::Properties => {
1251                            if properties__.is_some() {
1252                                return Err(serde::de::Error::duplicate_field("properties"));
1253                            }
1254                            properties__ = Some(
1255                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
1256                            );
1257                        }
1258                        GeneratedField::SnapshotDone => {
1259                            if snapshot_done__.is_some() {
1260                                return Err(serde::de::Error::duplicate_field("snapshotDone"));
1261                            }
1262                            snapshot_done__ = Some(map_.next_value()?);
1263                        }
1264                        GeneratedField::IsSourceJob => {
1265                            if is_source_job__.is_some() {
1266                                return Err(serde::de::Error::duplicate_field("isSourceJob"));
1267                            }
1268                            is_source_job__ = Some(map_.next_value()?);
1269                        }
1270                    }
1271                }
1272                Ok(GetEventStreamRequest {
1273                    source_id: source_id__.unwrap_or_default(),
1274                    source_type: source_type__.unwrap_or_default(),
1275                    start_offset: start_offset__.unwrap_or_default(),
1276                    properties: properties__.unwrap_or_default(),
1277                    snapshot_done: snapshot_done__.unwrap_or_default(),
1278                    is_source_job: is_source_job__.unwrap_or_default(),
1279                })
1280            }
1281        }
1282        deserializer.deserialize_struct("connector_service.GetEventStreamRequest", FIELDS, GeneratedVisitor)
1283    }
1284}
1285impl serde::Serialize for GetEventStreamResponse {
1286    #[allow(deprecated)]
1287    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1288    where
1289        S: serde::Serializer,
1290    {
1291        use serde::ser::SerializeStruct;
1292        let mut len = 0;
1293        if self.source_id != 0 {
1294            len += 1;
1295        }
1296        if !self.events.is_empty() {
1297            len += 1;
1298        }
1299        if self.control.is_some() {
1300            len += 1;
1301        }
1302        let mut struct_ser = serializer.serialize_struct("connector_service.GetEventStreamResponse", len)?;
1303        if self.source_id != 0 {
1304            #[allow(clippy::needless_borrow)]
1305            #[allow(clippy::needless_borrows_for_generic_args)]
1306            struct_ser.serialize_field("sourceId", ToString::to_string(&self.source_id).as_str())?;
1307        }
1308        if !self.events.is_empty() {
1309            struct_ser.serialize_field("events", &self.events)?;
1310        }
1311        if let Some(v) = self.control.as_ref() {
1312            struct_ser.serialize_field("control", v)?;
1313        }
1314        struct_ser.end()
1315    }
1316}
1317impl<'de> serde::Deserialize<'de> for GetEventStreamResponse {
1318    #[allow(deprecated)]
1319    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1320    where
1321        D: serde::Deserializer<'de>,
1322    {
1323        const FIELDS: &[&str] = &[
1324            "source_id",
1325            "sourceId",
1326            "events",
1327            "control",
1328        ];
1329
1330        #[allow(clippy::enum_variant_names)]
1331        enum GeneratedField {
1332            SourceId,
1333            Events,
1334            Control,
1335        }
1336        impl<'de> serde::Deserialize<'de> for GeneratedField {
1337            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1338            where
1339                D: serde::Deserializer<'de>,
1340            {
1341                struct GeneratedVisitor;
1342
1343                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1344                    type Value = GeneratedField;
1345
1346                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1347                        write!(formatter, "expected one of: {:?}", &FIELDS)
1348                    }
1349
1350                    #[allow(unused_variables)]
1351                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1352                    where
1353                        E: serde::de::Error,
1354                    {
1355                        match value {
1356                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
1357                            "events" => Ok(GeneratedField::Events),
1358                            "control" => Ok(GeneratedField::Control),
1359                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1360                        }
1361                    }
1362                }
1363                deserializer.deserialize_identifier(GeneratedVisitor)
1364            }
1365        }
1366        struct GeneratedVisitor;
1367        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1368            type Value = GetEventStreamResponse;
1369
1370            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1371                formatter.write_str("struct connector_service.GetEventStreamResponse")
1372            }
1373
1374            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GetEventStreamResponse, V::Error>
1375                where
1376                    V: serde::de::MapAccess<'de>,
1377            {
1378                let mut source_id__ = None;
1379                let mut events__ = None;
1380                let mut control__ = None;
1381                while let Some(k) = map_.next_key()? {
1382                    match k {
1383                        GeneratedField::SourceId => {
1384                            if source_id__.is_some() {
1385                                return Err(serde::de::Error::duplicate_field("sourceId"));
1386                            }
1387                            source_id__ = 
1388                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1389                            ;
1390                        }
1391                        GeneratedField::Events => {
1392                            if events__.is_some() {
1393                                return Err(serde::de::Error::duplicate_field("events"));
1394                            }
1395                            events__ = Some(map_.next_value()?);
1396                        }
1397                        GeneratedField::Control => {
1398                            if control__.is_some() {
1399                                return Err(serde::de::Error::duplicate_field("control"));
1400                            }
1401                            control__ = map_.next_value()?;
1402                        }
1403                    }
1404                }
1405                Ok(GetEventStreamResponse {
1406                    source_id: source_id__.unwrap_or_default(),
1407                    events: events__.unwrap_or_default(),
1408                    control: control__,
1409                })
1410            }
1411        }
1412        deserializer.deserialize_struct("connector_service.GetEventStreamResponse", FIELDS, GeneratedVisitor)
1413    }
1414}
1415impl serde::Serialize for get_event_stream_response::ControlInfo {
1416    #[allow(deprecated)]
1417    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1418    where
1419        S: serde::Serializer,
1420    {
1421        use serde::ser::SerializeStruct;
1422        let mut len = 0;
1423        if self.handshake_ok {
1424            len += 1;
1425        }
1426        let mut struct_ser = serializer.serialize_struct("connector_service.GetEventStreamResponse.ControlInfo", len)?;
1427        if self.handshake_ok {
1428            struct_ser.serialize_field("handshakeOk", &self.handshake_ok)?;
1429        }
1430        struct_ser.end()
1431    }
1432}
1433impl<'de> serde::Deserialize<'de> for get_event_stream_response::ControlInfo {
1434    #[allow(deprecated)]
1435    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1436    where
1437        D: serde::Deserializer<'de>,
1438    {
1439        const FIELDS: &[&str] = &[
1440            "handshake_ok",
1441            "handshakeOk",
1442        ];
1443
1444        #[allow(clippy::enum_variant_names)]
1445        enum GeneratedField {
1446            HandshakeOk,
1447        }
1448        impl<'de> serde::Deserialize<'de> for GeneratedField {
1449            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1450            where
1451                D: serde::Deserializer<'de>,
1452            {
1453                struct GeneratedVisitor;
1454
1455                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1456                    type Value = GeneratedField;
1457
1458                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1459                        write!(formatter, "expected one of: {:?}", &FIELDS)
1460                    }
1461
1462                    #[allow(unused_variables)]
1463                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1464                    where
1465                        E: serde::de::Error,
1466                    {
1467                        match value {
1468                            "handshakeOk" | "handshake_ok" => Ok(GeneratedField::HandshakeOk),
1469                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1470                        }
1471                    }
1472                }
1473                deserializer.deserialize_identifier(GeneratedVisitor)
1474            }
1475        }
1476        struct GeneratedVisitor;
1477        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1478            type Value = get_event_stream_response::ControlInfo;
1479
1480            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1481                formatter.write_str("struct connector_service.GetEventStreamResponse.ControlInfo")
1482            }
1483
1484            fn visit_map<V>(self, mut map_: V) -> std::result::Result<get_event_stream_response::ControlInfo, V::Error>
1485                where
1486                    V: serde::de::MapAccess<'de>,
1487            {
1488                let mut handshake_ok__ = None;
1489                while let Some(k) = map_.next_key()? {
1490                    match k {
1491                        GeneratedField::HandshakeOk => {
1492                            if handshake_ok__.is_some() {
1493                                return Err(serde::de::Error::duplicate_field("handshakeOk"));
1494                            }
1495                            handshake_ok__ = Some(map_.next_value()?);
1496                        }
1497                    }
1498                }
1499                Ok(get_event_stream_response::ControlInfo {
1500                    handshake_ok: handshake_ok__.unwrap_or_default(),
1501                })
1502            }
1503        }
1504        deserializer.deserialize_struct("connector_service.GetEventStreamResponse.ControlInfo", FIELDS, GeneratedVisitor)
1505    }
1506}
1507impl serde::Serialize for SinkCoordinatorStreamRequest {
1508    #[allow(deprecated)]
1509    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1510    where
1511        S: serde::Serializer,
1512    {
1513        use serde::ser::SerializeStruct;
1514        let mut len = 0;
1515        if self.request.is_some() {
1516            len += 1;
1517        }
1518        let mut struct_ser = serializer.serialize_struct("connector_service.SinkCoordinatorStreamRequest", len)?;
1519        if let Some(v) = self.request.as_ref() {
1520            match v {
1521                sink_coordinator_stream_request::Request::Start(v) => {
1522                    struct_ser.serialize_field("start", v)?;
1523                }
1524                sink_coordinator_stream_request::Request::Commit(v) => {
1525                    struct_ser.serialize_field("commit", v)?;
1526                }
1527            }
1528        }
1529        struct_ser.end()
1530    }
1531}
1532impl<'de> serde::Deserialize<'de> for SinkCoordinatorStreamRequest {
1533    #[allow(deprecated)]
1534    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1535    where
1536        D: serde::Deserializer<'de>,
1537    {
1538        const FIELDS: &[&str] = &[
1539            "start",
1540            "commit",
1541        ];
1542
1543        #[allow(clippy::enum_variant_names)]
1544        enum GeneratedField {
1545            Start,
1546            Commit,
1547        }
1548        impl<'de> serde::Deserialize<'de> for GeneratedField {
1549            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1550            where
1551                D: serde::Deserializer<'de>,
1552            {
1553                struct GeneratedVisitor;
1554
1555                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1556                    type Value = GeneratedField;
1557
1558                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1559                        write!(formatter, "expected one of: {:?}", &FIELDS)
1560                    }
1561
1562                    #[allow(unused_variables)]
1563                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1564                    where
1565                        E: serde::de::Error,
1566                    {
1567                        match value {
1568                            "start" => Ok(GeneratedField::Start),
1569                            "commit" => Ok(GeneratedField::Commit),
1570                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1571                        }
1572                    }
1573                }
1574                deserializer.deserialize_identifier(GeneratedVisitor)
1575            }
1576        }
1577        struct GeneratedVisitor;
1578        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1579            type Value = SinkCoordinatorStreamRequest;
1580
1581            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1582                formatter.write_str("struct connector_service.SinkCoordinatorStreamRequest")
1583            }
1584
1585            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkCoordinatorStreamRequest, V::Error>
1586                where
1587                    V: serde::de::MapAccess<'de>,
1588            {
1589                let mut request__ = None;
1590                while let Some(k) = map_.next_key()? {
1591                    match k {
1592                        GeneratedField::Start => {
1593                            if request__.is_some() {
1594                                return Err(serde::de::Error::duplicate_field("start"));
1595                            }
1596                            request__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_coordinator_stream_request::Request::Start)
1597;
1598                        }
1599                        GeneratedField::Commit => {
1600                            if request__.is_some() {
1601                                return Err(serde::de::Error::duplicate_field("commit"));
1602                            }
1603                            request__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_coordinator_stream_request::Request::Commit)
1604;
1605                        }
1606                    }
1607                }
1608                Ok(SinkCoordinatorStreamRequest {
1609                    request: request__,
1610                })
1611            }
1612        }
1613        deserializer.deserialize_struct("connector_service.SinkCoordinatorStreamRequest", FIELDS, GeneratedVisitor)
1614    }
1615}
1616impl serde::Serialize for sink_coordinator_stream_request::CommitMetadata {
1617    #[allow(deprecated)]
1618    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1619    where
1620        S: serde::Serializer,
1621    {
1622        use serde::ser::SerializeStruct;
1623        let mut len = 0;
1624        if self.epoch != 0 {
1625            len += 1;
1626        }
1627        if !self.metadata.is_empty() {
1628            len += 1;
1629        }
1630        let mut struct_ser = serializer.serialize_struct("connector_service.SinkCoordinatorStreamRequest.CommitMetadata", len)?;
1631        if self.epoch != 0 {
1632            #[allow(clippy::needless_borrow)]
1633            #[allow(clippy::needless_borrows_for_generic_args)]
1634            struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
1635        }
1636        if !self.metadata.is_empty() {
1637            struct_ser.serialize_field("metadata", &self.metadata)?;
1638        }
1639        struct_ser.end()
1640    }
1641}
1642impl<'de> serde::Deserialize<'de> for sink_coordinator_stream_request::CommitMetadata {
1643    #[allow(deprecated)]
1644    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1645    where
1646        D: serde::Deserializer<'de>,
1647    {
1648        const FIELDS: &[&str] = &[
1649            "epoch",
1650            "metadata",
1651        ];
1652
1653        #[allow(clippy::enum_variant_names)]
1654        enum GeneratedField {
1655            Epoch,
1656            Metadata,
1657        }
1658        impl<'de> serde::Deserialize<'de> for GeneratedField {
1659            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1660            where
1661                D: serde::Deserializer<'de>,
1662            {
1663                struct GeneratedVisitor;
1664
1665                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1666                    type Value = GeneratedField;
1667
1668                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1669                        write!(formatter, "expected one of: {:?}", &FIELDS)
1670                    }
1671
1672                    #[allow(unused_variables)]
1673                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1674                    where
1675                        E: serde::de::Error,
1676                    {
1677                        match value {
1678                            "epoch" => Ok(GeneratedField::Epoch),
1679                            "metadata" => Ok(GeneratedField::Metadata),
1680                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1681                        }
1682                    }
1683                }
1684                deserializer.deserialize_identifier(GeneratedVisitor)
1685            }
1686        }
1687        struct GeneratedVisitor;
1688        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1689            type Value = sink_coordinator_stream_request::CommitMetadata;
1690
1691            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1692                formatter.write_str("struct connector_service.SinkCoordinatorStreamRequest.CommitMetadata")
1693            }
1694
1695            fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_coordinator_stream_request::CommitMetadata, V::Error>
1696                where
1697                    V: serde::de::MapAccess<'de>,
1698            {
1699                let mut epoch__ = None;
1700                let mut metadata__ = None;
1701                while let Some(k) = map_.next_key()? {
1702                    match k {
1703                        GeneratedField::Epoch => {
1704                            if epoch__.is_some() {
1705                                return Err(serde::de::Error::duplicate_field("epoch"));
1706                            }
1707                            epoch__ = 
1708                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
1709                            ;
1710                        }
1711                        GeneratedField::Metadata => {
1712                            if metadata__.is_some() {
1713                                return Err(serde::de::Error::duplicate_field("metadata"));
1714                            }
1715                            metadata__ = Some(map_.next_value()?);
1716                        }
1717                    }
1718                }
1719                Ok(sink_coordinator_stream_request::CommitMetadata {
1720                    epoch: epoch__.unwrap_or_default(),
1721                    metadata: metadata__.unwrap_or_default(),
1722                })
1723            }
1724        }
1725        deserializer.deserialize_struct("connector_service.SinkCoordinatorStreamRequest.CommitMetadata", FIELDS, GeneratedVisitor)
1726    }
1727}
1728impl serde::Serialize for sink_coordinator_stream_request::StartCoordinator {
1729    #[allow(deprecated)]
1730    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1731    where
1732        S: serde::Serializer,
1733    {
1734        use serde::ser::SerializeStruct;
1735        let mut len = 0;
1736        if self.param.is_some() {
1737            len += 1;
1738        }
1739        let mut struct_ser = serializer.serialize_struct("connector_service.SinkCoordinatorStreamRequest.StartCoordinator", len)?;
1740        if let Some(v) = self.param.as_ref() {
1741            struct_ser.serialize_field("param", v)?;
1742        }
1743        struct_ser.end()
1744    }
1745}
1746impl<'de> serde::Deserialize<'de> for sink_coordinator_stream_request::StartCoordinator {
1747    #[allow(deprecated)]
1748    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1749    where
1750        D: serde::Deserializer<'de>,
1751    {
1752        const FIELDS: &[&str] = &[
1753            "param",
1754        ];
1755
1756        #[allow(clippy::enum_variant_names)]
1757        enum GeneratedField {
1758            Param,
1759        }
1760        impl<'de> serde::Deserialize<'de> for GeneratedField {
1761            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1762            where
1763                D: serde::Deserializer<'de>,
1764            {
1765                struct GeneratedVisitor;
1766
1767                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1768                    type Value = GeneratedField;
1769
1770                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1771                        write!(formatter, "expected one of: {:?}", &FIELDS)
1772                    }
1773
1774                    #[allow(unused_variables)]
1775                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1776                    where
1777                        E: serde::de::Error,
1778                    {
1779                        match value {
1780                            "param" => Ok(GeneratedField::Param),
1781                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1782                        }
1783                    }
1784                }
1785                deserializer.deserialize_identifier(GeneratedVisitor)
1786            }
1787        }
1788        struct GeneratedVisitor;
1789        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1790            type Value = sink_coordinator_stream_request::StartCoordinator;
1791
1792            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1793                formatter.write_str("struct connector_service.SinkCoordinatorStreamRequest.StartCoordinator")
1794            }
1795
1796            fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_coordinator_stream_request::StartCoordinator, V::Error>
1797                where
1798                    V: serde::de::MapAccess<'de>,
1799            {
1800                let mut param__ = None;
1801                while let Some(k) = map_.next_key()? {
1802                    match k {
1803                        GeneratedField::Param => {
1804                            if param__.is_some() {
1805                                return Err(serde::de::Error::duplicate_field("param"));
1806                            }
1807                            param__ = map_.next_value()?;
1808                        }
1809                    }
1810                }
1811                Ok(sink_coordinator_stream_request::StartCoordinator {
1812                    param: param__,
1813                })
1814            }
1815        }
1816        deserializer.deserialize_struct("connector_service.SinkCoordinatorStreamRequest.StartCoordinator", FIELDS, GeneratedVisitor)
1817    }
1818}
1819impl serde::Serialize for SinkCoordinatorStreamResponse {
1820    #[allow(deprecated)]
1821    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1822    where
1823        S: serde::Serializer,
1824    {
1825        use serde::ser::SerializeStruct;
1826        let mut len = 0;
1827        if self.response.is_some() {
1828            len += 1;
1829        }
1830        let mut struct_ser = serializer.serialize_struct("connector_service.SinkCoordinatorStreamResponse", len)?;
1831        if let Some(v) = self.response.as_ref() {
1832            match v {
1833                sink_coordinator_stream_response::Response::Start(v) => {
1834                    struct_ser.serialize_field("start", v)?;
1835                }
1836                sink_coordinator_stream_response::Response::Commit(v) => {
1837                    struct_ser.serialize_field("commit", v)?;
1838                }
1839            }
1840        }
1841        struct_ser.end()
1842    }
1843}
1844impl<'de> serde::Deserialize<'de> for SinkCoordinatorStreamResponse {
1845    #[allow(deprecated)]
1846    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1847    where
1848        D: serde::Deserializer<'de>,
1849    {
1850        const FIELDS: &[&str] = &[
1851            "start",
1852            "commit",
1853        ];
1854
1855        #[allow(clippy::enum_variant_names)]
1856        enum GeneratedField {
1857            Start,
1858            Commit,
1859        }
1860        impl<'de> serde::Deserialize<'de> for GeneratedField {
1861            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1862            where
1863                D: serde::Deserializer<'de>,
1864            {
1865                struct GeneratedVisitor;
1866
1867                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1868                    type Value = GeneratedField;
1869
1870                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1871                        write!(formatter, "expected one of: {:?}", &FIELDS)
1872                    }
1873
1874                    #[allow(unused_variables)]
1875                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1876                    where
1877                        E: serde::de::Error,
1878                    {
1879                        match value {
1880                            "start" => Ok(GeneratedField::Start),
1881                            "commit" => Ok(GeneratedField::Commit),
1882                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1883                        }
1884                    }
1885                }
1886                deserializer.deserialize_identifier(GeneratedVisitor)
1887            }
1888        }
1889        struct GeneratedVisitor;
1890        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1891            type Value = SinkCoordinatorStreamResponse;
1892
1893            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1894                formatter.write_str("struct connector_service.SinkCoordinatorStreamResponse")
1895            }
1896
1897            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkCoordinatorStreamResponse, V::Error>
1898                where
1899                    V: serde::de::MapAccess<'de>,
1900            {
1901                let mut response__ = None;
1902                while let Some(k) = map_.next_key()? {
1903                    match k {
1904                        GeneratedField::Start => {
1905                            if response__.is_some() {
1906                                return Err(serde::de::Error::duplicate_field("start"));
1907                            }
1908                            response__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_coordinator_stream_response::Response::Start)
1909;
1910                        }
1911                        GeneratedField::Commit => {
1912                            if response__.is_some() {
1913                                return Err(serde::de::Error::duplicate_field("commit"));
1914                            }
1915                            response__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_coordinator_stream_response::Response::Commit)
1916;
1917                        }
1918                    }
1919                }
1920                Ok(SinkCoordinatorStreamResponse {
1921                    response: response__,
1922                })
1923            }
1924        }
1925        deserializer.deserialize_struct("connector_service.SinkCoordinatorStreamResponse", FIELDS, GeneratedVisitor)
1926    }
1927}
1928impl serde::Serialize for sink_coordinator_stream_response::CommitResponse {
1929    #[allow(deprecated)]
1930    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1931    where
1932        S: serde::Serializer,
1933    {
1934        use serde::ser::SerializeStruct;
1935        let mut len = 0;
1936        if self.epoch != 0 {
1937            len += 1;
1938        }
1939        let mut struct_ser = serializer.serialize_struct("connector_service.SinkCoordinatorStreamResponse.CommitResponse", len)?;
1940        if self.epoch != 0 {
1941            #[allow(clippy::needless_borrow)]
1942            #[allow(clippy::needless_borrows_for_generic_args)]
1943            struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
1944        }
1945        struct_ser.end()
1946    }
1947}
1948impl<'de> serde::Deserialize<'de> for sink_coordinator_stream_response::CommitResponse {
1949    #[allow(deprecated)]
1950    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1951    where
1952        D: serde::Deserializer<'de>,
1953    {
1954        const FIELDS: &[&str] = &[
1955            "epoch",
1956        ];
1957
1958        #[allow(clippy::enum_variant_names)]
1959        enum GeneratedField {
1960            Epoch,
1961        }
1962        impl<'de> serde::Deserialize<'de> for GeneratedField {
1963            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1964            where
1965                D: serde::Deserializer<'de>,
1966            {
1967                struct GeneratedVisitor;
1968
1969                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1970                    type Value = GeneratedField;
1971
1972                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1973                        write!(formatter, "expected one of: {:?}", &FIELDS)
1974                    }
1975
1976                    #[allow(unused_variables)]
1977                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1978                    where
1979                        E: serde::de::Error,
1980                    {
1981                        match value {
1982                            "epoch" => Ok(GeneratedField::Epoch),
1983                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1984                        }
1985                    }
1986                }
1987                deserializer.deserialize_identifier(GeneratedVisitor)
1988            }
1989        }
1990        struct GeneratedVisitor;
1991        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1992            type Value = sink_coordinator_stream_response::CommitResponse;
1993
1994            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1995                formatter.write_str("struct connector_service.SinkCoordinatorStreamResponse.CommitResponse")
1996            }
1997
1998            fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_coordinator_stream_response::CommitResponse, V::Error>
1999                where
2000                    V: serde::de::MapAccess<'de>,
2001            {
2002                let mut epoch__ = None;
2003                while let Some(k) = map_.next_key()? {
2004                    match k {
2005                        GeneratedField::Epoch => {
2006                            if epoch__.is_some() {
2007                                return Err(serde::de::Error::duplicate_field("epoch"));
2008                            }
2009                            epoch__ = 
2010                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2011                            ;
2012                        }
2013                    }
2014                }
2015                Ok(sink_coordinator_stream_response::CommitResponse {
2016                    epoch: epoch__.unwrap_or_default(),
2017                })
2018            }
2019        }
2020        deserializer.deserialize_struct("connector_service.SinkCoordinatorStreamResponse.CommitResponse", FIELDS, GeneratedVisitor)
2021    }
2022}
2023impl serde::Serialize for sink_coordinator_stream_response::StartResponse {
2024    #[allow(deprecated)]
2025    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2026    where
2027        S: serde::Serializer,
2028    {
2029        use serde::ser::SerializeStruct;
2030        let len = 0;
2031        let struct_ser = serializer.serialize_struct("connector_service.SinkCoordinatorStreamResponse.StartResponse", len)?;
2032        struct_ser.end()
2033    }
2034}
2035impl<'de> serde::Deserialize<'de> for sink_coordinator_stream_response::StartResponse {
2036    #[allow(deprecated)]
2037    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2038    where
2039        D: serde::Deserializer<'de>,
2040    {
2041        const FIELDS: &[&str] = &[
2042        ];
2043
2044        #[allow(clippy::enum_variant_names)]
2045        enum GeneratedField {
2046        }
2047        impl<'de> serde::Deserialize<'de> for GeneratedField {
2048            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2049            where
2050                D: serde::Deserializer<'de>,
2051            {
2052                struct GeneratedVisitor;
2053
2054                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2055                    type Value = GeneratedField;
2056
2057                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2058                        write!(formatter, "expected one of: {:?}", &FIELDS)
2059                    }
2060
2061                    #[allow(unused_variables)]
2062                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2063                    where
2064                        E: serde::de::Error,
2065                    {
2066                            Err(serde::de::Error::unknown_field(value, FIELDS))
2067                    }
2068                }
2069                deserializer.deserialize_identifier(GeneratedVisitor)
2070            }
2071        }
2072        struct GeneratedVisitor;
2073        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2074            type Value = sink_coordinator_stream_response::StartResponse;
2075
2076            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2077                formatter.write_str("struct connector_service.SinkCoordinatorStreamResponse.StartResponse")
2078            }
2079
2080            fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_coordinator_stream_response::StartResponse, V::Error>
2081                where
2082                    V: serde::de::MapAccess<'de>,
2083            {
2084                while map_.next_key::<GeneratedField>()?.is_some() {
2085                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2086                }
2087                Ok(sink_coordinator_stream_response::StartResponse {
2088                })
2089            }
2090        }
2091        deserializer.deserialize_struct("connector_service.SinkCoordinatorStreamResponse.StartResponse", FIELDS, GeneratedVisitor)
2092    }
2093}
2094impl serde::Serialize for SinkMetadata {
2095    #[allow(deprecated)]
2096    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2097    where
2098        S: serde::Serializer,
2099    {
2100        use serde::ser::SerializeStruct;
2101        let mut len = 0;
2102        if self.metadata.is_some() {
2103            len += 1;
2104        }
2105        let mut struct_ser = serializer.serialize_struct("connector_service.SinkMetadata", len)?;
2106        if let Some(v) = self.metadata.as_ref() {
2107            match v {
2108                sink_metadata::Metadata::Serialized(v) => {
2109                    struct_ser.serialize_field("serialized", v)?;
2110                }
2111            }
2112        }
2113        struct_ser.end()
2114    }
2115}
2116impl<'de> serde::Deserialize<'de> for SinkMetadata {
2117    #[allow(deprecated)]
2118    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2119    where
2120        D: serde::Deserializer<'de>,
2121    {
2122        const FIELDS: &[&str] = &[
2123            "serialized",
2124        ];
2125
2126        #[allow(clippy::enum_variant_names)]
2127        enum GeneratedField {
2128            Serialized,
2129        }
2130        impl<'de> serde::Deserialize<'de> for GeneratedField {
2131            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2132            where
2133                D: serde::Deserializer<'de>,
2134            {
2135                struct GeneratedVisitor;
2136
2137                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2138                    type Value = GeneratedField;
2139
2140                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2141                        write!(formatter, "expected one of: {:?}", &FIELDS)
2142                    }
2143
2144                    #[allow(unused_variables)]
2145                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2146                    where
2147                        E: serde::de::Error,
2148                    {
2149                        match value {
2150                            "serialized" => Ok(GeneratedField::Serialized),
2151                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2152                        }
2153                    }
2154                }
2155                deserializer.deserialize_identifier(GeneratedVisitor)
2156            }
2157        }
2158        struct GeneratedVisitor;
2159        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2160            type Value = SinkMetadata;
2161
2162            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2163                formatter.write_str("struct connector_service.SinkMetadata")
2164            }
2165
2166            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkMetadata, V::Error>
2167                where
2168                    V: serde::de::MapAccess<'de>,
2169            {
2170                let mut metadata__ = None;
2171                while let Some(k) = map_.next_key()? {
2172                    match k {
2173                        GeneratedField::Serialized => {
2174                            if metadata__.is_some() {
2175                                return Err(serde::de::Error::duplicate_field("serialized"));
2176                            }
2177                            metadata__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_metadata::Metadata::Serialized)
2178;
2179                        }
2180                    }
2181                }
2182                Ok(SinkMetadata {
2183                    metadata: metadata__,
2184                })
2185            }
2186        }
2187        deserializer.deserialize_struct("connector_service.SinkMetadata", FIELDS, GeneratedVisitor)
2188    }
2189}
2190impl serde::Serialize for sink_metadata::SerializedMetadata {
2191    #[allow(deprecated)]
2192    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2193    where
2194        S: serde::Serializer,
2195    {
2196        use serde::ser::SerializeStruct;
2197        let mut len = 0;
2198        if !self.metadata.is_empty() {
2199            len += 1;
2200        }
2201        let mut struct_ser = serializer.serialize_struct("connector_service.SinkMetadata.SerializedMetadata", len)?;
2202        if !self.metadata.is_empty() {
2203            #[allow(clippy::needless_borrow)]
2204            #[allow(clippy::needless_borrows_for_generic_args)]
2205            struct_ser.serialize_field("metadata", pbjson::private::base64::encode(&self.metadata).as_str())?;
2206        }
2207        struct_ser.end()
2208    }
2209}
2210impl<'de> serde::Deserialize<'de> for sink_metadata::SerializedMetadata {
2211    #[allow(deprecated)]
2212    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2213    where
2214        D: serde::Deserializer<'de>,
2215    {
2216        const FIELDS: &[&str] = &[
2217            "metadata",
2218        ];
2219
2220        #[allow(clippy::enum_variant_names)]
2221        enum GeneratedField {
2222            Metadata,
2223        }
2224        impl<'de> serde::Deserialize<'de> for GeneratedField {
2225            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2226            where
2227                D: serde::Deserializer<'de>,
2228            {
2229                struct GeneratedVisitor;
2230
2231                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2232                    type Value = GeneratedField;
2233
2234                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2235                        write!(formatter, "expected one of: {:?}", &FIELDS)
2236                    }
2237
2238                    #[allow(unused_variables)]
2239                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2240                    where
2241                        E: serde::de::Error,
2242                    {
2243                        match value {
2244                            "metadata" => Ok(GeneratedField::Metadata),
2245                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2246                        }
2247                    }
2248                }
2249                deserializer.deserialize_identifier(GeneratedVisitor)
2250            }
2251        }
2252        struct GeneratedVisitor;
2253        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2254            type Value = sink_metadata::SerializedMetadata;
2255
2256            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2257                formatter.write_str("struct connector_service.SinkMetadata.SerializedMetadata")
2258            }
2259
2260            fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_metadata::SerializedMetadata, V::Error>
2261                where
2262                    V: serde::de::MapAccess<'de>,
2263            {
2264                let mut metadata__ = None;
2265                while let Some(k) = map_.next_key()? {
2266                    match k {
2267                        GeneratedField::Metadata => {
2268                            if metadata__.is_some() {
2269                                return Err(serde::de::Error::duplicate_field("metadata"));
2270                            }
2271                            metadata__ = 
2272                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
2273                            ;
2274                        }
2275                    }
2276                }
2277                Ok(sink_metadata::SerializedMetadata {
2278                    metadata: metadata__.unwrap_or_default(),
2279                })
2280            }
2281        }
2282        deserializer.deserialize_struct("connector_service.SinkMetadata.SerializedMetadata", FIELDS, GeneratedVisitor)
2283    }
2284}
2285impl serde::Serialize for SinkParam {
2286    #[allow(deprecated)]
2287    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2288    where
2289        S: serde::Serializer,
2290    {
2291        use serde::ser::SerializeStruct;
2292        let mut len = 0;
2293        if self.sink_id != 0 {
2294            len += 1;
2295        }
2296        if !self.properties.is_empty() {
2297            len += 1;
2298        }
2299        if self.table_schema.is_some() {
2300            len += 1;
2301        }
2302        if self.sink_type != 0 {
2303            len += 1;
2304        }
2305        if !self.db_name.is_empty() {
2306            len += 1;
2307        }
2308        if !self.sink_from_name.is_empty() {
2309            len += 1;
2310        }
2311        if self.format_desc.is_some() {
2312            len += 1;
2313        }
2314        if !self.sink_name.is_empty() {
2315            len += 1;
2316        }
2317        let mut struct_ser = serializer.serialize_struct("connector_service.SinkParam", len)?;
2318        if self.sink_id != 0 {
2319            struct_ser.serialize_field("sinkId", &self.sink_id)?;
2320        }
2321        if !self.properties.is_empty() {
2322            struct_ser.serialize_field("properties", &self.properties)?;
2323        }
2324        if let Some(v) = self.table_schema.as_ref() {
2325            struct_ser.serialize_field("tableSchema", v)?;
2326        }
2327        if self.sink_type != 0 {
2328            let v = super::catalog::SinkType::try_from(self.sink_type)
2329                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
2330            struct_ser.serialize_field("sinkType", &v)?;
2331        }
2332        if !self.db_name.is_empty() {
2333            struct_ser.serialize_field("dbName", &self.db_name)?;
2334        }
2335        if !self.sink_from_name.is_empty() {
2336            struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
2337        }
2338        if let Some(v) = self.format_desc.as_ref() {
2339            struct_ser.serialize_field("formatDesc", v)?;
2340        }
2341        if !self.sink_name.is_empty() {
2342            struct_ser.serialize_field("sinkName", &self.sink_name)?;
2343        }
2344        struct_ser.end()
2345    }
2346}
2347impl<'de> serde::Deserialize<'de> for SinkParam {
2348    #[allow(deprecated)]
2349    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2350    where
2351        D: serde::Deserializer<'de>,
2352    {
2353        const FIELDS: &[&str] = &[
2354            "sink_id",
2355            "sinkId",
2356            "properties",
2357            "table_schema",
2358            "tableSchema",
2359            "sink_type",
2360            "sinkType",
2361            "db_name",
2362            "dbName",
2363            "sink_from_name",
2364            "sinkFromName",
2365            "format_desc",
2366            "formatDesc",
2367            "sink_name",
2368            "sinkName",
2369        ];
2370
2371        #[allow(clippy::enum_variant_names)]
2372        enum GeneratedField {
2373            SinkId,
2374            Properties,
2375            TableSchema,
2376            SinkType,
2377            DbName,
2378            SinkFromName,
2379            FormatDesc,
2380            SinkName,
2381        }
2382        impl<'de> serde::Deserialize<'de> for GeneratedField {
2383            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2384            where
2385                D: serde::Deserializer<'de>,
2386            {
2387                struct GeneratedVisitor;
2388
2389                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2390                    type Value = GeneratedField;
2391
2392                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2393                        write!(formatter, "expected one of: {:?}", &FIELDS)
2394                    }
2395
2396                    #[allow(unused_variables)]
2397                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2398                    where
2399                        E: serde::de::Error,
2400                    {
2401                        match value {
2402                            "sinkId" | "sink_id" => Ok(GeneratedField::SinkId),
2403                            "properties" => Ok(GeneratedField::Properties),
2404                            "tableSchema" | "table_schema" => Ok(GeneratedField::TableSchema),
2405                            "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
2406                            "dbName" | "db_name" => Ok(GeneratedField::DbName),
2407                            "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
2408                            "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
2409                            "sinkName" | "sink_name" => Ok(GeneratedField::SinkName),
2410                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2411                        }
2412                    }
2413                }
2414                deserializer.deserialize_identifier(GeneratedVisitor)
2415            }
2416        }
2417        struct GeneratedVisitor;
2418        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2419            type Value = SinkParam;
2420
2421            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2422                formatter.write_str("struct connector_service.SinkParam")
2423            }
2424
2425            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkParam, V::Error>
2426                where
2427                    V: serde::de::MapAccess<'de>,
2428            {
2429                let mut sink_id__ = None;
2430                let mut properties__ = None;
2431                let mut table_schema__ = None;
2432                let mut sink_type__ = None;
2433                let mut db_name__ = None;
2434                let mut sink_from_name__ = None;
2435                let mut format_desc__ = None;
2436                let mut sink_name__ = None;
2437                while let Some(k) = map_.next_key()? {
2438                    match k {
2439                        GeneratedField::SinkId => {
2440                            if sink_id__.is_some() {
2441                                return Err(serde::de::Error::duplicate_field("sinkId"));
2442                            }
2443                            sink_id__ = 
2444                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2445                            ;
2446                        }
2447                        GeneratedField::Properties => {
2448                            if properties__.is_some() {
2449                                return Err(serde::de::Error::duplicate_field("properties"));
2450                            }
2451                            properties__ = Some(
2452                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
2453                            );
2454                        }
2455                        GeneratedField::TableSchema => {
2456                            if table_schema__.is_some() {
2457                                return Err(serde::de::Error::duplicate_field("tableSchema"));
2458                            }
2459                            table_schema__ = map_.next_value()?;
2460                        }
2461                        GeneratedField::SinkType => {
2462                            if sink_type__.is_some() {
2463                                return Err(serde::de::Error::duplicate_field("sinkType"));
2464                            }
2465                            sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
2466                        }
2467                        GeneratedField::DbName => {
2468                            if db_name__.is_some() {
2469                                return Err(serde::de::Error::duplicate_field("dbName"));
2470                            }
2471                            db_name__ = Some(map_.next_value()?);
2472                        }
2473                        GeneratedField::SinkFromName => {
2474                            if sink_from_name__.is_some() {
2475                                return Err(serde::de::Error::duplicate_field("sinkFromName"));
2476                            }
2477                            sink_from_name__ = Some(map_.next_value()?);
2478                        }
2479                        GeneratedField::FormatDesc => {
2480                            if format_desc__.is_some() {
2481                                return Err(serde::de::Error::duplicate_field("formatDesc"));
2482                            }
2483                            format_desc__ = map_.next_value()?;
2484                        }
2485                        GeneratedField::SinkName => {
2486                            if sink_name__.is_some() {
2487                                return Err(serde::de::Error::duplicate_field("sinkName"));
2488                            }
2489                            sink_name__ = Some(map_.next_value()?);
2490                        }
2491                    }
2492                }
2493                Ok(SinkParam {
2494                    sink_id: sink_id__.unwrap_or_default(),
2495                    properties: properties__.unwrap_or_default(),
2496                    table_schema: table_schema__,
2497                    sink_type: sink_type__.unwrap_or_default(),
2498                    db_name: db_name__.unwrap_or_default(),
2499                    sink_from_name: sink_from_name__.unwrap_or_default(),
2500                    format_desc: format_desc__,
2501                    sink_name: sink_name__.unwrap_or_default(),
2502                })
2503            }
2504        }
2505        deserializer.deserialize_struct("connector_service.SinkParam", FIELDS, GeneratedVisitor)
2506    }
2507}
2508impl serde::Serialize for SinkWriterStreamRequest {
2509    #[allow(deprecated)]
2510    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2511    where
2512        S: serde::Serializer,
2513    {
2514        use serde::ser::SerializeStruct;
2515        let mut len = 0;
2516        if self.request.is_some() {
2517            len += 1;
2518        }
2519        let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamRequest", len)?;
2520        if let Some(v) = self.request.as_ref() {
2521            match v {
2522                sink_writer_stream_request::Request::Start(v) => {
2523                    struct_ser.serialize_field("start", v)?;
2524                }
2525                sink_writer_stream_request::Request::WriteBatch(v) => {
2526                    struct_ser.serialize_field("writeBatch", v)?;
2527                }
2528                sink_writer_stream_request::Request::Barrier(v) => {
2529                    struct_ser.serialize_field("barrier", v)?;
2530                }
2531            }
2532        }
2533        struct_ser.end()
2534    }
2535}
2536impl<'de> serde::Deserialize<'de> for SinkWriterStreamRequest {
2537    #[allow(deprecated)]
2538    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2539    where
2540        D: serde::Deserializer<'de>,
2541    {
2542        const FIELDS: &[&str] = &[
2543            "start",
2544            "write_batch",
2545            "writeBatch",
2546            "barrier",
2547        ];
2548
2549        #[allow(clippy::enum_variant_names)]
2550        enum GeneratedField {
2551            Start,
2552            WriteBatch,
2553            Barrier,
2554        }
2555        impl<'de> serde::Deserialize<'de> for GeneratedField {
2556            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2557            where
2558                D: serde::Deserializer<'de>,
2559            {
2560                struct GeneratedVisitor;
2561
2562                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2563                    type Value = GeneratedField;
2564
2565                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2566                        write!(formatter, "expected one of: {:?}", &FIELDS)
2567                    }
2568
2569                    #[allow(unused_variables)]
2570                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2571                    where
2572                        E: serde::de::Error,
2573                    {
2574                        match value {
2575                            "start" => Ok(GeneratedField::Start),
2576                            "writeBatch" | "write_batch" => Ok(GeneratedField::WriteBatch),
2577                            "barrier" => Ok(GeneratedField::Barrier),
2578                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2579                        }
2580                    }
2581                }
2582                deserializer.deserialize_identifier(GeneratedVisitor)
2583            }
2584        }
2585        struct GeneratedVisitor;
2586        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2587            type Value = SinkWriterStreamRequest;
2588
2589            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2590                formatter.write_str("struct connector_service.SinkWriterStreamRequest")
2591            }
2592
2593            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkWriterStreamRequest, V::Error>
2594                where
2595                    V: serde::de::MapAccess<'de>,
2596            {
2597                let mut request__ = None;
2598                while let Some(k) = map_.next_key()? {
2599                    match k {
2600                        GeneratedField::Start => {
2601                            if request__.is_some() {
2602                                return Err(serde::de::Error::duplicate_field("start"));
2603                            }
2604                            request__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_request::Request::Start)
2605;
2606                        }
2607                        GeneratedField::WriteBatch => {
2608                            if request__.is_some() {
2609                                return Err(serde::de::Error::duplicate_field("writeBatch"));
2610                            }
2611                            request__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_request::Request::WriteBatch)
2612;
2613                        }
2614                        GeneratedField::Barrier => {
2615                            if request__.is_some() {
2616                                return Err(serde::de::Error::duplicate_field("barrier"));
2617                            }
2618                            request__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_request::Request::Barrier)
2619;
2620                        }
2621                    }
2622                }
2623                Ok(SinkWriterStreamRequest {
2624                    request: request__,
2625                })
2626            }
2627        }
2628        deserializer.deserialize_struct("connector_service.SinkWriterStreamRequest", FIELDS, GeneratedVisitor)
2629    }
2630}
2631impl serde::Serialize for sink_writer_stream_request::Barrier {
2632    #[allow(deprecated)]
2633    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2634    where
2635        S: serde::Serializer,
2636    {
2637        use serde::ser::SerializeStruct;
2638        let mut len = 0;
2639        if self.epoch != 0 {
2640            len += 1;
2641        }
2642        if self.is_checkpoint {
2643            len += 1;
2644        }
2645        let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamRequest.Barrier", len)?;
2646        if self.epoch != 0 {
2647            #[allow(clippy::needless_borrow)]
2648            #[allow(clippy::needless_borrows_for_generic_args)]
2649            struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
2650        }
2651        if self.is_checkpoint {
2652            struct_ser.serialize_field("isCheckpoint", &self.is_checkpoint)?;
2653        }
2654        struct_ser.end()
2655    }
2656}
2657impl<'de> serde::Deserialize<'de> for sink_writer_stream_request::Barrier {
2658    #[allow(deprecated)]
2659    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2660    where
2661        D: serde::Deserializer<'de>,
2662    {
2663        const FIELDS: &[&str] = &[
2664            "epoch",
2665            "is_checkpoint",
2666            "isCheckpoint",
2667        ];
2668
2669        #[allow(clippy::enum_variant_names)]
2670        enum GeneratedField {
2671            Epoch,
2672            IsCheckpoint,
2673        }
2674        impl<'de> serde::Deserialize<'de> for GeneratedField {
2675            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2676            where
2677                D: serde::Deserializer<'de>,
2678            {
2679                struct GeneratedVisitor;
2680
2681                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2682                    type Value = GeneratedField;
2683
2684                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2685                        write!(formatter, "expected one of: {:?}", &FIELDS)
2686                    }
2687
2688                    #[allow(unused_variables)]
2689                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2690                    where
2691                        E: serde::de::Error,
2692                    {
2693                        match value {
2694                            "epoch" => Ok(GeneratedField::Epoch),
2695                            "isCheckpoint" | "is_checkpoint" => Ok(GeneratedField::IsCheckpoint),
2696                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2697                        }
2698                    }
2699                }
2700                deserializer.deserialize_identifier(GeneratedVisitor)
2701            }
2702        }
2703        struct GeneratedVisitor;
2704        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2705            type Value = sink_writer_stream_request::Barrier;
2706
2707            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2708                formatter.write_str("struct connector_service.SinkWriterStreamRequest.Barrier")
2709            }
2710
2711            fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_request::Barrier, V::Error>
2712                where
2713                    V: serde::de::MapAccess<'de>,
2714            {
2715                let mut epoch__ = None;
2716                let mut is_checkpoint__ = None;
2717                while let Some(k) = map_.next_key()? {
2718                    match k {
2719                        GeneratedField::Epoch => {
2720                            if epoch__.is_some() {
2721                                return Err(serde::de::Error::duplicate_field("epoch"));
2722                            }
2723                            epoch__ = 
2724                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2725                            ;
2726                        }
2727                        GeneratedField::IsCheckpoint => {
2728                            if is_checkpoint__.is_some() {
2729                                return Err(serde::de::Error::duplicate_field("isCheckpoint"));
2730                            }
2731                            is_checkpoint__ = Some(map_.next_value()?);
2732                        }
2733                    }
2734                }
2735                Ok(sink_writer_stream_request::Barrier {
2736                    epoch: epoch__.unwrap_or_default(),
2737                    is_checkpoint: is_checkpoint__.unwrap_or_default(),
2738                })
2739            }
2740        }
2741        deserializer.deserialize_struct("connector_service.SinkWriterStreamRequest.Barrier", FIELDS, GeneratedVisitor)
2742    }
2743}
2744impl serde::Serialize for sink_writer_stream_request::StartSink {
2745    #[allow(deprecated)]
2746    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2747    where
2748        S: serde::Serializer,
2749    {
2750        use serde::ser::SerializeStruct;
2751        let mut len = 0;
2752        if self.sink_param.is_some() {
2753            len += 1;
2754        }
2755        if self.payload_schema.is_some() {
2756            len += 1;
2757        }
2758        let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamRequest.StartSink", len)?;
2759        if let Some(v) = self.sink_param.as_ref() {
2760            struct_ser.serialize_field("sinkParam", v)?;
2761        }
2762        if let Some(v) = self.payload_schema.as_ref() {
2763            struct_ser.serialize_field("payloadSchema", v)?;
2764        }
2765        struct_ser.end()
2766    }
2767}
2768impl<'de> serde::Deserialize<'de> for sink_writer_stream_request::StartSink {
2769    #[allow(deprecated)]
2770    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2771    where
2772        D: serde::Deserializer<'de>,
2773    {
2774        const FIELDS: &[&str] = &[
2775            "sink_param",
2776            "sinkParam",
2777            "payload_schema",
2778            "payloadSchema",
2779        ];
2780
2781        #[allow(clippy::enum_variant_names)]
2782        enum GeneratedField {
2783            SinkParam,
2784            PayloadSchema,
2785        }
2786        impl<'de> serde::Deserialize<'de> for GeneratedField {
2787            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2788            where
2789                D: serde::Deserializer<'de>,
2790            {
2791                struct GeneratedVisitor;
2792
2793                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2794                    type Value = GeneratedField;
2795
2796                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2797                        write!(formatter, "expected one of: {:?}", &FIELDS)
2798                    }
2799
2800                    #[allow(unused_variables)]
2801                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2802                    where
2803                        E: serde::de::Error,
2804                    {
2805                        match value {
2806                            "sinkParam" | "sink_param" => Ok(GeneratedField::SinkParam),
2807                            "payloadSchema" | "payload_schema" => Ok(GeneratedField::PayloadSchema),
2808                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2809                        }
2810                    }
2811                }
2812                deserializer.deserialize_identifier(GeneratedVisitor)
2813            }
2814        }
2815        struct GeneratedVisitor;
2816        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2817            type Value = sink_writer_stream_request::StartSink;
2818
2819            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2820                formatter.write_str("struct connector_service.SinkWriterStreamRequest.StartSink")
2821            }
2822
2823            fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_request::StartSink, V::Error>
2824                where
2825                    V: serde::de::MapAccess<'de>,
2826            {
2827                let mut sink_param__ = None;
2828                let mut payload_schema__ = None;
2829                while let Some(k) = map_.next_key()? {
2830                    match k {
2831                        GeneratedField::SinkParam => {
2832                            if sink_param__.is_some() {
2833                                return Err(serde::de::Error::duplicate_field("sinkParam"));
2834                            }
2835                            sink_param__ = map_.next_value()?;
2836                        }
2837                        GeneratedField::PayloadSchema => {
2838                            if payload_schema__.is_some() {
2839                                return Err(serde::de::Error::duplicate_field("payloadSchema"));
2840                            }
2841                            payload_schema__ = map_.next_value()?;
2842                        }
2843                    }
2844                }
2845                Ok(sink_writer_stream_request::StartSink {
2846                    sink_param: sink_param__,
2847                    payload_schema: payload_schema__,
2848                })
2849            }
2850        }
2851        deserializer.deserialize_struct("connector_service.SinkWriterStreamRequest.StartSink", FIELDS, GeneratedVisitor)
2852    }
2853}
2854impl serde::Serialize for sink_writer_stream_request::WriteBatch {
2855    #[allow(deprecated)]
2856    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2857    where
2858        S: serde::Serializer,
2859    {
2860        use serde::ser::SerializeStruct;
2861        let mut len = 0;
2862        if self.batch_id != 0 {
2863            len += 1;
2864        }
2865        if self.epoch != 0 {
2866            len += 1;
2867        }
2868        if self.payload.is_some() {
2869            len += 1;
2870        }
2871        let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamRequest.WriteBatch", len)?;
2872        if self.batch_id != 0 {
2873            #[allow(clippy::needless_borrow)]
2874            #[allow(clippy::needless_borrows_for_generic_args)]
2875            struct_ser.serialize_field("batchId", ToString::to_string(&self.batch_id).as_str())?;
2876        }
2877        if self.epoch != 0 {
2878            #[allow(clippy::needless_borrow)]
2879            #[allow(clippy::needless_borrows_for_generic_args)]
2880            struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
2881        }
2882        if let Some(v) = self.payload.as_ref() {
2883            match v {
2884                sink_writer_stream_request::write_batch::Payload::StreamChunkPayload(v) => {
2885                    struct_ser.serialize_field("streamChunkPayload", v)?;
2886                }
2887                sink_writer_stream_request::write_batch::Payload::StreamChunkRefPointer(v) => {
2888                    #[allow(clippy::needless_borrow)]
2889                    #[allow(clippy::needless_borrows_for_generic_args)]
2890                    struct_ser.serialize_field("streamChunkRefPointer", ToString::to_string(&v).as_str())?;
2891                }
2892            }
2893        }
2894        struct_ser.end()
2895    }
2896}
2897impl<'de> serde::Deserialize<'de> for sink_writer_stream_request::WriteBatch {
2898    #[allow(deprecated)]
2899    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2900    where
2901        D: serde::Deserializer<'de>,
2902    {
2903        const FIELDS: &[&str] = &[
2904            "batch_id",
2905            "batchId",
2906            "epoch",
2907            "stream_chunk_payload",
2908            "streamChunkPayload",
2909            "stream_chunk_ref_pointer",
2910            "streamChunkRefPointer",
2911        ];
2912
2913        #[allow(clippy::enum_variant_names)]
2914        enum GeneratedField {
2915            BatchId,
2916            Epoch,
2917            StreamChunkPayload,
2918            StreamChunkRefPointer,
2919        }
2920        impl<'de> serde::Deserialize<'de> for GeneratedField {
2921            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2922            where
2923                D: serde::Deserializer<'de>,
2924            {
2925                struct GeneratedVisitor;
2926
2927                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2928                    type Value = GeneratedField;
2929
2930                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2931                        write!(formatter, "expected one of: {:?}", &FIELDS)
2932                    }
2933
2934                    #[allow(unused_variables)]
2935                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2936                    where
2937                        E: serde::de::Error,
2938                    {
2939                        match value {
2940                            "batchId" | "batch_id" => Ok(GeneratedField::BatchId),
2941                            "epoch" => Ok(GeneratedField::Epoch),
2942                            "streamChunkPayload" | "stream_chunk_payload" => Ok(GeneratedField::StreamChunkPayload),
2943                            "streamChunkRefPointer" | "stream_chunk_ref_pointer" => Ok(GeneratedField::StreamChunkRefPointer),
2944                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2945                        }
2946                    }
2947                }
2948                deserializer.deserialize_identifier(GeneratedVisitor)
2949            }
2950        }
2951        struct GeneratedVisitor;
2952        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2953            type Value = sink_writer_stream_request::WriteBatch;
2954
2955            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2956                formatter.write_str("struct connector_service.SinkWriterStreamRequest.WriteBatch")
2957            }
2958
2959            fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_request::WriteBatch, V::Error>
2960                where
2961                    V: serde::de::MapAccess<'de>,
2962            {
2963                let mut batch_id__ = None;
2964                let mut epoch__ = None;
2965                let mut payload__ = None;
2966                while let Some(k) = map_.next_key()? {
2967                    match k {
2968                        GeneratedField::BatchId => {
2969                            if batch_id__.is_some() {
2970                                return Err(serde::de::Error::duplicate_field("batchId"));
2971                            }
2972                            batch_id__ = 
2973                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2974                            ;
2975                        }
2976                        GeneratedField::Epoch => {
2977                            if epoch__.is_some() {
2978                                return Err(serde::de::Error::duplicate_field("epoch"));
2979                            }
2980                            epoch__ = 
2981                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2982                            ;
2983                        }
2984                        GeneratedField::StreamChunkPayload => {
2985                            if payload__.is_some() {
2986                                return Err(serde::de::Error::duplicate_field("streamChunkPayload"));
2987                            }
2988                            payload__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_request::write_batch::Payload::StreamChunkPayload)
2989;
2990                        }
2991                        GeneratedField::StreamChunkRefPointer => {
2992                            if payload__.is_some() {
2993                                return Err(serde::de::Error::duplicate_field("streamChunkRefPointer"));
2994                            }
2995                            payload__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| sink_writer_stream_request::write_batch::Payload::StreamChunkRefPointer(x.0));
2996                        }
2997                    }
2998                }
2999                Ok(sink_writer_stream_request::WriteBatch {
3000                    batch_id: batch_id__.unwrap_or_default(),
3001                    epoch: epoch__.unwrap_or_default(),
3002                    payload: payload__,
3003                })
3004            }
3005        }
3006        deserializer.deserialize_struct("connector_service.SinkWriterStreamRequest.WriteBatch", FIELDS, GeneratedVisitor)
3007    }
3008}
3009impl serde::Serialize for sink_writer_stream_request::write_batch::StreamChunkPayload {
3010    #[allow(deprecated)]
3011    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3012    where
3013        S: serde::Serializer,
3014    {
3015        use serde::ser::SerializeStruct;
3016        let mut len = 0;
3017        if !self.binary_data.is_empty() {
3018            len += 1;
3019        }
3020        let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamRequest.WriteBatch.StreamChunkPayload", len)?;
3021        if !self.binary_data.is_empty() {
3022            #[allow(clippy::needless_borrow)]
3023            #[allow(clippy::needless_borrows_for_generic_args)]
3024            struct_ser.serialize_field("binaryData", pbjson::private::base64::encode(&self.binary_data).as_str())?;
3025        }
3026        struct_ser.end()
3027    }
3028}
3029impl<'de> serde::Deserialize<'de> for sink_writer_stream_request::write_batch::StreamChunkPayload {
3030    #[allow(deprecated)]
3031    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3032    where
3033        D: serde::Deserializer<'de>,
3034    {
3035        const FIELDS: &[&str] = &[
3036            "binary_data",
3037            "binaryData",
3038        ];
3039
3040        #[allow(clippy::enum_variant_names)]
3041        enum GeneratedField {
3042            BinaryData,
3043        }
3044        impl<'de> serde::Deserialize<'de> for GeneratedField {
3045            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3046            where
3047                D: serde::Deserializer<'de>,
3048            {
3049                struct GeneratedVisitor;
3050
3051                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3052                    type Value = GeneratedField;
3053
3054                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3055                        write!(formatter, "expected one of: {:?}", &FIELDS)
3056                    }
3057
3058                    #[allow(unused_variables)]
3059                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3060                    where
3061                        E: serde::de::Error,
3062                    {
3063                        match value {
3064                            "binaryData" | "binary_data" => Ok(GeneratedField::BinaryData),
3065                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3066                        }
3067                    }
3068                }
3069                deserializer.deserialize_identifier(GeneratedVisitor)
3070            }
3071        }
3072        struct GeneratedVisitor;
3073        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3074            type Value = sink_writer_stream_request::write_batch::StreamChunkPayload;
3075
3076            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3077                formatter.write_str("struct connector_service.SinkWriterStreamRequest.WriteBatch.StreamChunkPayload")
3078            }
3079
3080            fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_request::write_batch::StreamChunkPayload, V::Error>
3081                where
3082                    V: serde::de::MapAccess<'de>,
3083            {
3084                let mut binary_data__ = None;
3085                while let Some(k) = map_.next_key()? {
3086                    match k {
3087                        GeneratedField::BinaryData => {
3088                            if binary_data__.is_some() {
3089                                return Err(serde::de::Error::duplicate_field("binaryData"));
3090                            }
3091                            binary_data__ = 
3092                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
3093                            ;
3094                        }
3095                    }
3096                }
3097                Ok(sink_writer_stream_request::write_batch::StreamChunkPayload {
3098                    binary_data: binary_data__.unwrap_or_default(),
3099                })
3100            }
3101        }
3102        deserializer.deserialize_struct("connector_service.SinkWriterStreamRequest.WriteBatch.StreamChunkPayload", FIELDS, GeneratedVisitor)
3103    }
3104}
3105impl serde::Serialize for SinkWriterStreamResponse {
3106    #[allow(deprecated)]
3107    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3108    where
3109        S: serde::Serializer,
3110    {
3111        use serde::ser::SerializeStruct;
3112        let mut len = 0;
3113        if self.response.is_some() {
3114            len += 1;
3115        }
3116        let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamResponse", len)?;
3117        if let Some(v) = self.response.as_ref() {
3118            match v {
3119                sink_writer_stream_response::Response::Start(v) => {
3120                    struct_ser.serialize_field("start", v)?;
3121                }
3122                sink_writer_stream_response::Response::Commit(v) => {
3123                    struct_ser.serialize_field("commit", v)?;
3124                }
3125                sink_writer_stream_response::Response::Batch(v) => {
3126                    struct_ser.serialize_field("batch", v)?;
3127                }
3128            }
3129        }
3130        struct_ser.end()
3131    }
3132}
3133impl<'de> serde::Deserialize<'de> for SinkWriterStreamResponse {
3134    #[allow(deprecated)]
3135    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3136    where
3137        D: serde::Deserializer<'de>,
3138    {
3139        const FIELDS: &[&str] = &[
3140            "start",
3141            "commit",
3142            "batch",
3143        ];
3144
3145        #[allow(clippy::enum_variant_names)]
3146        enum GeneratedField {
3147            Start,
3148            Commit,
3149            Batch,
3150        }
3151        impl<'de> serde::Deserialize<'de> for GeneratedField {
3152            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3153            where
3154                D: serde::Deserializer<'de>,
3155            {
3156                struct GeneratedVisitor;
3157
3158                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3159                    type Value = GeneratedField;
3160
3161                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3162                        write!(formatter, "expected one of: {:?}", &FIELDS)
3163                    }
3164
3165                    #[allow(unused_variables)]
3166                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3167                    where
3168                        E: serde::de::Error,
3169                    {
3170                        match value {
3171                            "start" => Ok(GeneratedField::Start),
3172                            "commit" => Ok(GeneratedField::Commit),
3173                            "batch" => Ok(GeneratedField::Batch),
3174                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3175                        }
3176                    }
3177                }
3178                deserializer.deserialize_identifier(GeneratedVisitor)
3179            }
3180        }
3181        struct GeneratedVisitor;
3182        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3183            type Value = SinkWriterStreamResponse;
3184
3185            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3186                formatter.write_str("struct connector_service.SinkWriterStreamResponse")
3187            }
3188
3189            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkWriterStreamResponse, V::Error>
3190                where
3191                    V: serde::de::MapAccess<'de>,
3192            {
3193                let mut response__ = None;
3194                while let Some(k) = map_.next_key()? {
3195                    match k {
3196                        GeneratedField::Start => {
3197                            if response__.is_some() {
3198                                return Err(serde::de::Error::duplicate_field("start"));
3199                            }
3200                            response__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_response::Response::Start)
3201;
3202                        }
3203                        GeneratedField::Commit => {
3204                            if response__.is_some() {
3205                                return Err(serde::de::Error::duplicate_field("commit"));
3206                            }
3207                            response__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_response::Response::Commit)
3208;
3209                        }
3210                        GeneratedField::Batch => {
3211                            if response__.is_some() {
3212                                return Err(serde::de::Error::duplicate_field("batch"));
3213                            }
3214                            response__ = map_.next_value::<::std::option::Option<_>>()?.map(sink_writer_stream_response::Response::Batch)
3215;
3216                        }
3217                    }
3218                }
3219                Ok(SinkWriterStreamResponse {
3220                    response: response__,
3221                })
3222            }
3223        }
3224        deserializer.deserialize_struct("connector_service.SinkWriterStreamResponse", FIELDS, GeneratedVisitor)
3225    }
3226}
3227impl serde::Serialize for sink_writer_stream_response::BatchWrittenResponse {
3228    #[allow(deprecated)]
3229    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3230    where
3231        S: serde::Serializer,
3232    {
3233        use serde::ser::SerializeStruct;
3234        let mut len = 0;
3235        if self.epoch != 0 {
3236            len += 1;
3237        }
3238        if self.batch_id != 0 {
3239            len += 1;
3240        }
3241        let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamResponse.BatchWrittenResponse", len)?;
3242        if self.epoch != 0 {
3243            #[allow(clippy::needless_borrow)]
3244            #[allow(clippy::needless_borrows_for_generic_args)]
3245            struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
3246        }
3247        if self.batch_id != 0 {
3248            #[allow(clippy::needless_borrow)]
3249            #[allow(clippy::needless_borrows_for_generic_args)]
3250            struct_ser.serialize_field("batchId", ToString::to_string(&self.batch_id).as_str())?;
3251        }
3252        struct_ser.end()
3253    }
3254}
3255impl<'de> serde::Deserialize<'de> for sink_writer_stream_response::BatchWrittenResponse {
3256    #[allow(deprecated)]
3257    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3258    where
3259        D: serde::Deserializer<'de>,
3260    {
3261        const FIELDS: &[&str] = &[
3262            "epoch",
3263            "batch_id",
3264            "batchId",
3265        ];
3266
3267        #[allow(clippy::enum_variant_names)]
3268        enum GeneratedField {
3269            Epoch,
3270            BatchId,
3271        }
3272        impl<'de> serde::Deserialize<'de> for GeneratedField {
3273            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3274            where
3275                D: serde::Deserializer<'de>,
3276            {
3277                struct GeneratedVisitor;
3278
3279                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3280                    type Value = GeneratedField;
3281
3282                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3283                        write!(formatter, "expected one of: {:?}", &FIELDS)
3284                    }
3285
3286                    #[allow(unused_variables)]
3287                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3288                    where
3289                        E: serde::de::Error,
3290                    {
3291                        match value {
3292                            "epoch" => Ok(GeneratedField::Epoch),
3293                            "batchId" | "batch_id" => Ok(GeneratedField::BatchId),
3294                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3295                        }
3296                    }
3297                }
3298                deserializer.deserialize_identifier(GeneratedVisitor)
3299            }
3300        }
3301        struct GeneratedVisitor;
3302        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3303            type Value = sink_writer_stream_response::BatchWrittenResponse;
3304
3305            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3306                formatter.write_str("struct connector_service.SinkWriterStreamResponse.BatchWrittenResponse")
3307            }
3308
3309            fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_response::BatchWrittenResponse, V::Error>
3310                where
3311                    V: serde::de::MapAccess<'de>,
3312            {
3313                let mut epoch__ = None;
3314                let mut batch_id__ = None;
3315                while let Some(k) = map_.next_key()? {
3316                    match k {
3317                        GeneratedField::Epoch => {
3318                            if epoch__.is_some() {
3319                                return Err(serde::de::Error::duplicate_field("epoch"));
3320                            }
3321                            epoch__ = 
3322                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3323                            ;
3324                        }
3325                        GeneratedField::BatchId => {
3326                            if batch_id__.is_some() {
3327                                return Err(serde::de::Error::duplicate_field("batchId"));
3328                            }
3329                            batch_id__ = 
3330                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3331                            ;
3332                        }
3333                    }
3334                }
3335                Ok(sink_writer_stream_response::BatchWrittenResponse {
3336                    epoch: epoch__.unwrap_or_default(),
3337                    batch_id: batch_id__.unwrap_or_default(),
3338                })
3339            }
3340        }
3341        deserializer.deserialize_struct("connector_service.SinkWriterStreamResponse.BatchWrittenResponse", FIELDS, GeneratedVisitor)
3342    }
3343}
3344impl serde::Serialize for sink_writer_stream_response::CommitResponse {
3345    #[allow(deprecated)]
3346    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3347    where
3348        S: serde::Serializer,
3349    {
3350        use serde::ser::SerializeStruct;
3351        let mut len = 0;
3352        if self.epoch != 0 {
3353            len += 1;
3354        }
3355        if self.metadata.is_some() {
3356            len += 1;
3357        }
3358        let mut struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamResponse.CommitResponse", len)?;
3359        if self.epoch != 0 {
3360            #[allow(clippy::needless_borrow)]
3361            #[allow(clippy::needless_borrows_for_generic_args)]
3362            struct_ser.serialize_field("epoch", ToString::to_string(&self.epoch).as_str())?;
3363        }
3364        if let Some(v) = self.metadata.as_ref() {
3365            struct_ser.serialize_field("metadata", v)?;
3366        }
3367        struct_ser.end()
3368    }
3369}
3370impl<'de> serde::Deserialize<'de> for sink_writer_stream_response::CommitResponse {
3371    #[allow(deprecated)]
3372    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3373    where
3374        D: serde::Deserializer<'de>,
3375    {
3376        const FIELDS: &[&str] = &[
3377            "epoch",
3378            "metadata",
3379        ];
3380
3381        #[allow(clippy::enum_variant_names)]
3382        enum GeneratedField {
3383            Epoch,
3384            Metadata,
3385        }
3386        impl<'de> serde::Deserialize<'de> for GeneratedField {
3387            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3388            where
3389                D: serde::Deserializer<'de>,
3390            {
3391                struct GeneratedVisitor;
3392
3393                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3394                    type Value = GeneratedField;
3395
3396                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3397                        write!(formatter, "expected one of: {:?}", &FIELDS)
3398                    }
3399
3400                    #[allow(unused_variables)]
3401                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3402                    where
3403                        E: serde::de::Error,
3404                    {
3405                        match value {
3406                            "epoch" => Ok(GeneratedField::Epoch),
3407                            "metadata" => Ok(GeneratedField::Metadata),
3408                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3409                        }
3410                    }
3411                }
3412                deserializer.deserialize_identifier(GeneratedVisitor)
3413            }
3414        }
3415        struct GeneratedVisitor;
3416        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3417            type Value = sink_writer_stream_response::CommitResponse;
3418
3419            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3420                formatter.write_str("struct connector_service.SinkWriterStreamResponse.CommitResponse")
3421            }
3422
3423            fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_response::CommitResponse, V::Error>
3424                where
3425                    V: serde::de::MapAccess<'de>,
3426            {
3427                let mut epoch__ = None;
3428                let mut metadata__ = None;
3429                while let Some(k) = map_.next_key()? {
3430                    match k {
3431                        GeneratedField::Epoch => {
3432                            if epoch__.is_some() {
3433                                return Err(serde::de::Error::duplicate_field("epoch"));
3434                            }
3435                            epoch__ = 
3436                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3437                            ;
3438                        }
3439                        GeneratedField::Metadata => {
3440                            if metadata__.is_some() {
3441                                return Err(serde::de::Error::duplicate_field("metadata"));
3442                            }
3443                            metadata__ = map_.next_value()?;
3444                        }
3445                    }
3446                }
3447                Ok(sink_writer_stream_response::CommitResponse {
3448                    epoch: epoch__.unwrap_or_default(),
3449                    metadata: metadata__,
3450                })
3451            }
3452        }
3453        deserializer.deserialize_struct("connector_service.SinkWriterStreamResponse.CommitResponse", FIELDS, GeneratedVisitor)
3454    }
3455}
3456impl serde::Serialize for sink_writer_stream_response::StartResponse {
3457    #[allow(deprecated)]
3458    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3459    where
3460        S: serde::Serializer,
3461    {
3462        use serde::ser::SerializeStruct;
3463        let len = 0;
3464        let struct_ser = serializer.serialize_struct("connector_service.SinkWriterStreamResponse.StartResponse", len)?;
3465        struct_ser.end()
3466    }
3467}
3468impl<'de> serde::Deserialize<'de> for sink_writer_stream_response::StartResponse {
3469    #[allow(deprecated)]
3470    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3471    where
3472        D: serde::Deserializer<'de>,
3473    {
3474        const FIELDS: &[&str] = &[
3475        ];
3476
3477        #[allow(clippy::enum_variant_names)]
3478        enum GeneratedField {
3479        }
3480        impl<'de> serde::Deserialize<'de> for GeneratedField {
3481            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3482            where
3483                D: serde::Deserializer<'de>,
3484            {
3485                struct GeneratedVisitor;
3486
3487                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3488                    type Value = GeneratedField;
3489
3490                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3491                        write!(formatter, "expected one of: {:?}", &FIELDS)
3492                    }
3493
3494                    #[allow(unused_variables)]
3495                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3496                    where
3497                        E: serde::de::Error,
3498                    {
3499                            Err(serde::de::Error::unknown_field(value, FIELDS))
3500                    }
3501                }
3502                deserializer.deserialize_identifier(GeneratedVisitor)
3503            }
3504        }
3505        struct GeneratedVisitor;
3506        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3507            type Value = sink_writer_stream_response::StartResponse;
3508
3509            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3510                formatter.write_str("struct connector_service.SinkWriterStreamResponse.StartResponse")
3511            }
3512
3513            fn visit_map<V>(self, mut map_: V) -> std::result::Result<sink_writer_stream_response::StartResponse, V::Error>
3514                where
3515                    V: serde::de::MapAccess<'de>,
3516            {
3517                while map_.next_key::<GeneratedField>()?.is_some() {
3518                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
3519                }
3520                Ok(sink_writer_stream_response::StartResponse {
3521                })
3522            }
3523        }
3524        deserializer.deserialize_struct("connector_service.SinkWriterStreamResponse.StartResponse", FIELDS, GeneratedVisitor)
3525    }
3526}
3527impl serde::Serialize for SourceType {
3528    #[allow(deprecated)]
3529    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3530    where
3531        S: serde::Serializer,
3532    {
3533        let variant = match self {
3534            Self::Unspecified => "UNSPECIFIED",
3535            Self::Mysql => "MYSQL",
3536            Self::Postgres => "POSTGRES",
3537            Self::Citus => "CITUS",
3538            Self::Mongodb => "MONGODB",
3539            Self::SqlServer => "SQL_SERVER",
3540        };
3541        serializer.serialize_str(variant)
3542    }
3543}
3544impl<'de> serde::Deserialize<'de> for SourceType {
3545    #[allow(deprecated)]
3546    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3547    where
3548        D: serde::Deserializer<'de>,
3549    {
3550        const FIELDS: &[&str] = &[
3551            "UNSPECIFIED",
3552            "MYSQL",
3553            "POSTGRES",
3554            "CITUS",
3555            "MONGODB",
3556            "SQL_SERVER",
3557        ];
3558
3559        struct GeneratedVisitor;
3560
3561        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3562            type Value = SourceType;
3563
3564            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3565                write!(formatter, "expected one of: {:?}", &FIELDS)
3566            }
3567
3568            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3569            where
3570                E: serde::de::Error,
3571            {
3572                i32::try_from(v)
3573                    .ok()
3574                    .and_then(|x| x.try_into().ok())
3575                    .ok_or_else(|| {
3576                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3577                    })
3578            }
3579
3580            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3581            where
3582                E: serde::de::Error,
3583            {
3584                i32::try_from(v)
3585                    .ok()
3586                    .and_then(|x| x.try_into().ok())
3587                    .ok_or_else(|| {
3588                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3589                    })
3590            }
3591
3592            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3593            where
3594                E: serde::de::Error,
3595            {
3596                match value {
3597                    "UNSPECIFIED" => Ok(SourceType::Unspecified),
3598                    "MYSQL" => Ok(SourceType::Mysql),
3599                    "POSTGRES" => Ok(SourceType::Postgres),
3600                    "CITUS" => Ok(SourceType::Citus),
3601                    "MONGODB" => Ok(SourceType::Mongodb),
3602                    "SQL_SERVER" => Ok(SourceType::SqlServer),
3603                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3604                }
3605            }
3606        }
3607        deserializer.deserialize_any(GeneratedVisitor)
3608    }
3609}
3610impl serde::Serialize for TableSchema {
3611    #[allow(deprecated)]
3612    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3613    where
3614        S: serde::Serializer,
3615    {
3616        use serde::ser::SerializeStruct;
3617        let mut len = 0;
3618        if !self.columns.is_empty() {
3619            len += 1;
3620        }
3621        if !self.pk_indices.is_empty() {
3622            len += 1;
3623        }
3624        let mut struct_ser = serializer.serialize_struct("connector_service.TableSchema", len)?;
3625        if !self.columns.is_empty() {
3626            struct_ser.serialize_field("columns", &self.columns)?;
3627        }
3628        if !self.pk_indices.is_empty() {
3629            struct_ser.serialize_field("pkIndices", &self.pk_indices)?;
3630        }
3631        struct_ser.end()
3632    }
3633}
3634impl<'de> serde::Deserialize<'de> for TableSchema {
3635    #[allow(deprecated)]
3636    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3637    where
3638        D: serde::Deserializer<'de>,
3639    {
3640        const FIELDS: &[&str] = &[
3641            "columns",
3642            "pk_indices",
3643            "pkIndices",
3644        ];
3645
3646        #[allow(clippy::enum_variant_names)]
3647        enum GeneratedField {
3648            Columns,
3649            PkIndices,
3650        }
3651        impl<'de> serde::Deserialize<'de> for GeneratedField {
3652            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3653            where
3654                D: serde::Deserializer<'de>,
3655            {
3656                struct GeneratedVisitor;
3657
3658                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3659                    type Value = GeneratedField;
3660
3661                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3662                        write!(formatter, "expected one of: {:?}", &FIELDS)
3663                    }
3664
3665                    #[allow(unused_variables)]
3666                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3667                    where
3668                        E: serde::de::Error,
3669                    {
3670                        match value {
3671                            "columns" => Ok(GeneratedField::Columns),
3672                            "pkIndices" | "pk_indices" => Ok(GeneratedField::PkIndices),
3673                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3674                        }
3675                    }
3676                }
3677                deserializer.deserialize_identifier(GeneratedVisitor)
3678            }
3679        }
3680        struct GeneratedVisitor;
3681        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3682            type Value = TableSchema;
3683
3684            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3685                formatter.write_str("struct connector_service.TableSchema")
3686            }
3687
3688            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TableSchema, V::Error>
3689                where
3690                    V: serde::de::MapAccess<'de>,
3691            {
3692                let mut columns__ = None;
3693                let mut pk_indices__ = None;
3694                while let Some(k) = map_.next_key()? {
3695                    match k {
3696                        GeneratedField::Columns => {
3697                            if columns__.is_some() {
3698                                return Err(serde::de::Error::duplicate_field("columns"));
3699                            }
3700                            columns__ = Some(map_.next_value()?);
3701                        }
3702                        GeneratedField::PkIndices => {
3703                            if pk_indices__.is_some() {
3704                                return Err(serde::de::Error::duplicate_field("pkIndices"));
3705                            }
3706                            pk_indices__ = 
3707                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3708                                    .into_iter().map(|x| x.0).collect())
3709                            ;
3710                        }
3711                    }
3712                }
3713                Ok(TableSchema {
3714                    columns: columns__.unwrap_or_default(),
3715                    pk_indices: pk_indices__.unwrap_or_default(),
3716                })
3717            }
3718        }
3719        deserializer.deserialize_struct("connector_service.TableSchema", FIELDS, GeneratedVisitor)
3720    }
3721}
3722impl serde::Serialize for ValidateSinkRequest {
3723    #[allow(deprecated)]
3724    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3725    where
3726        S: serde::Serializer,
3727    {
3728        use serde::ser::SerializeStruct;
3729        let mut len = 0;
3730        if self.sink_param.is_some() {
3731            len += 1;
3732        }
3733        let mut struct_ser = serializer.serialize_struct("connector_service.ValidateSinkRequest", len)?;
3734        if let Some(v) = self.sink_param.as_ref() {
3735            struct_ser.serialize_field("sinkParam", v)?;
3736        }
3737        struct_ser.end()
3738    }
3739}
3740impl<'de> serde::Deserialize<'de> for ValidateSinkRequest {
3741    #[allow(deprecated)]
3742    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3743    where
3744        D: serde::Deserializer<'de>,
3745    {
3746        const FIELDS: &[&str] = &[
3747            "sink_param",
3748            "sinkParam",
3749        ];
3750
3751        #[allow(clippy::enum_variant_names)]
3752        enum GeneratedField {
3753            SinkParam,
3754        }
3755        impl<'de> serde::Deserialize<'de> for GeneratedField {
3756            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3757            where
3758                D: serde::Deserializer<'de>,
3759            {
3760                struct GeneratedVisitor;
3761
3762                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3763                    type Value = GeneratedField;
3764
3765                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3766                        write!(formatter, "expected one of: {:?}", &FIELDS)
3767                    }
3768
3769                    #[allow(unused_variables)]
3770                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3771                    where
3772                        E: serde::de::Error,
3773                    {
3774                        match value {
3775                            "sinkParam" | "sink_param" => Ok(GeneratedField::SinkParam),
3776                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3777                        }
3778                    }
3779                }
3780                deserializer.deserialize_identifier(GeneratedVisitor)
3781            }
3782        }
3783        struct GeneratedVisitor;
3784        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3785            type Value = ValidateSinkRequest;
3786
3787            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3788                formatter.write_str("struct connector_service.ValidateSinkRequest")
3789            }
3790
3791            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidateSinkRequest, V::Error>
3792                where
3793                    V: serde::de::MapAccess<'de>,
3794            {
3795                let mut sink_param__ = None;
3796                while let Some(k) = map_.next_key()? {
3797                    match k {
3798                        GeneratedField::SinkParam => {
3799                            if sink_param__.is_some() {
3800                                return Err(serde::de::Error::duplicate_field("sinkParam"));
3801                            }
3802                            sink_param__ = map_.next_value()?;
3803                        }
3804                    }
3805                }
3806                Ok(ValidateSinkRequest {
3807                    sink_param: sink_param__,
3808                })
3809            }
3810        }
3811        deserializer.deserialize_struct("connector_service.ValidateSinkRequest", FIELDS, GeneratedVisitor)
3812    }
3813}
3814impl serde::Serialize for ValidateSinkResponse {
3815    #[allow(deprecated)]
3816    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3817    where
3818        S: serde::Serializer,
3819    {
3820        use serde::ser::SerializeStruct;
3821        let mut len = 0;
3822        if self.error.is_some() {
3823            len += 1;
3824        }
3825        let mut struct_ser = serializer.serialize_struct("connector_service.ValidateSinkResponse", len)?;
3826        if let Some(v) = self.error.as_ref() {
3827            struct_ser.serialize_field("error", v)?;
3828        }
3829        struct_ser.end()
3830    }
3831}
3832impl<'de> serde::Deserialize<'de> for ValidateSinkResponse {
3833    #[allow(deprecated)]
3834    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3835    where
3836        D: serde::Deserializer<'de>,
3837    {
3838        const FIELDS: &[&str] = &[
3839            "error",
3840        ];
3841
3842        #[allow(clippy::enum_variant_names)]
3843        enum GeneratedField {
3844            Error,
3845        }
3846        impl<'de> serde::Deserialize<'de> for GeneratedField {
3847            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3848            where
3849                D: serde::Deserializer<'de>,
3850            {
3851                struct GeneratedVisitor;
3852
3853                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3854                    type Value = GeneratedField;
3855
3856                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3857                        write!(formatter, "expected one of: {:?}", &FIELDS)
3858                    }
3859
3860                    #[allow(unused_variables)]
3861                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3862                    where
3863                        E: serde::de::Error,
3864                    {
3865                        match value {
3866                            "error" => Ok(GeneratedField::Error),
3867                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3868                        }
3869                    }
3870                }
3871                deserializer.deserialize_identifier(GeneratedVisitor)
3872            }
3873        }
3874        struct GeneratedVisitor;
3875        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3876            type Value = ValidateSinkResponse;
3877
3878            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3879                formatter.write_str("struct connector_service.ValidateSinkResponse")
3880            }
3881
3882            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidateSinkResponse, V::Error>
3883                where
3884                    V: serde::de::MapAccess<'de>,
3885            {
3886                let mut error__ = None;
3887                while let Some(k) = map_.next_key()? {
3888                    match k {
3889                        GeneratedField::Error => {
3890                            if error__.is_some() {
3891                                return Err(serde::de::Error::duplicate_field("error"));
3892                            }
3893                            error__ = map_.next_value()?;
3894                        }
3895                    }
3896                }
3897                Ok(ValidateSinkResponse {
3898                    error: error__,
3899                })
3900            }
3901        }
3902        deserializer.deserialize_struct("connector_service.ValidateSinkResponse", FIELDS, GeneratedVisitor)
3903    }
3904}
3905impl serde::Serialize for ValidateSourceRequest {
3906    #[allow(deprecated)]
3907    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3908    where
3909        S: serde::Serializer,
3910    {
3911        use serde::ser::SerializeStruct;
3912        let mut len = 0;
3913        if self.source_id != 0 {
3914            len += 1;
3915        }
3916        if self.source_type != 0 {
3917            len += 1;
3918        }
3919        if !self.properties.is_empty() {
3920            len += 1;
3921        }
3922        if self.table_schema.is_some() {
3923            len += 1;
3924        }
3925        if self.is_source_job {
3926            len += 1;
3927        }
3928        if self.is_backfill_table {
3929            len += 1;
3930        }
3931        let mut struct_ser = serializer.serialize_struct("connector_service.ValidateSourceRequest", len)?;
3932        if self.source_id != 0 {
3933            #[allow(clippy::needless_borrow)]
3934            #[allow(clippy::needless_borrows_for_generic_args)]
3935            struct_ser.serialize_field("sourceId", ToString::to_string(&self.source_id).as_str())?;
3936        }
3937        if self.source_type != 0 {
3938            let v = SourceType::try_from(self.source_type)
3939                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.source_type)))?;
3940            struct_ser.serialize_field("sourceType", &v)?;
3941        }
3942        if !self.properties.is_empty() {
3943            struct_ser.serialize_field("properties", &self.properties)?;
3944        }
3945        if let Some(v) = self.table_schema.as_ref() {
3946            struct_ser.serialize_field("tableSchema", v)?;
3947        }
3948        if self.is_source_job {
3949            struct_ser.serialize_field("isSourceJob", &self.is_source_job)?;
3950        }
3951        if self.is_backfill_table {
3952            struct_ser.serialize_field("isBackfillTable", &self.is_backfill_table)?;
3953        }
3954        struct_ser.end()
3955    }
3956}
3957impl<'de> serde::Deserialize<'de> for ValidateSourceRequest {
3958    #[allow(deprecated)]
3959    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3960    where
3961        D: serde::Deserializer<'de>,
3962    {
3963        const FIELDS: &[&str] = &[
3964            "source_id",
3965            "sourceId",
3966            "source_type",
3967            "sourceType",
3968            "properties",
3969            "table_schema",
3970            "tableSchema",
3971            "is_source_job",
3972            "isSourceJob",
3973            "is_backfill_table",
3974            "isBackfillTable",
3975        ];
3976
3977        #[allow(clippy::enum_variant_names)]
3978        enum GeneratedField {
3979            SourceId,
3980            SourceType,
3981            Properties,
3982            TableSchema,
3983            IsSourceJob,
3984            IsBackfillTable,
3985        }
3986        impl<'de> serde::Deserialize<'de> for GeneratedField {
3987            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3988            where
3989                D: serde::Deserializer<'de>,
3990            {
3991                struct GeneratedVisitor;
3992
3993                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3994                    type Value = GeneratedField;
3995
3996                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3997                        write!(formatter, "expected one of: {:?}", &FIELDS)
3998                    }
3999
4000                    #[allow(unused_variables)]
4001                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4002                    where
4003                        E: serde::de::Error,
4004                    {
4005                        match value {
4006                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
4007                            "sourceType" | "source_type" => Ok(GeneratedField::SourceType),
4008                            "properties" => Ok(GeneratedField::Properties),
4009                            "tableSchema" | "table_schema" => Ok(GeneratedField::TableSchema),
4010                            "isSourceJob" | "is_source_job" => Ok(GeneratedField::IsSourceJob),
4011                            "isBackfillTable" | "is_backfill_table" => Ok(GeneratedField::IsBackfillTable),
4012                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4013                        }
4014                    }
4015                }
4016                deserializer.deserialize_identifier(GeneratedVisitor)
4017            }
4018        }
4019        struct GeneratedVisitor;
4020        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4021            type Value = ValidateSourceRequest;
4022
4023            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4024                formatter.write_str("struct connector_service.ValidateSourceRequest")
4025            }
4026
4027            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidateSourceRequest, V::Error>
4028                where
4029                    V: serde::de::MapAccess<'de>,
4030            {
4031                let mut source_id__ = None;
4032                let mut source_type__ = None;
4033                let mut properties__ = None;
4034                let mut table_schema__ = None;
4035                let mut is_source_job__ = None;
4036                let mut is_backfill_table__ = None;
4037                while let Some(k) = map_.next_key()? {
4038                    match k {
4039                        GeneratedField::SourceId => {
4040                            if source_id__.is_some() {
4041                                return Err(serde::de::Error::duplicate_field("sourceId"));
4042                            }
4043                            source_id__ = 
4044                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4045                            ;
4046                        }
4047                        GeneratedField::SourceType => {
4048                            if source_type__.is_some() {
4049                                return Err(serde::de::Error::duplicate_field("sourceType"));
4050                            }
4051                            source_type__ = Some(map_.next_value::<SourceType>()? as i32);
4052                        }
4053                        GeneratedField::Properties => {
4054                            if properties__.is_some() {
4055                                return Err(serde::de::Error::duplicate_field("properties"));
4056                            }
4057                            properties__ = Some(
4058                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
4059                            );
4060                        }
4061                        GeneratedField::TableSchema => {
4062                            if table_schema__.is_some() {
4063                                return Err(serde::de::Error::duplicate_field("tableSchema"));
4064                            }
4065                            table_schema__ = map_.next_value()?;
4066                        }
4067                        GeneratedField::IsSourceJob => {
4068                            if is_source_job__.is_some() {
4069                                return Err(serde::de::Error::duplicate_field("isSourceJob"));
4070                            }
4071                            is_source_job__ = Some(map_.next_value()?);
4072                        }
4073                        GeneratedField::IsBackfillTable => {
4074                            if is_backfill_table__.is_some() {
4075                                return Err(serde::de::Error::duplicate_field("isBackfillTable"));
4076                            }
4077                            is_backfill_table__ = Some(map_.next_value()?);
4078                        }
4079                    }
4080                }
4081                Ok(ValidateSourceRequest {
4082                    source_id: source_id__.unwrap_or_default(),
4083                    source_type: source_type__.unwrap_or_default(),
4084                    properties: properties__.unwrap_or_default(),
4085                    table_schema: table_schema__,
4086                    is_source_job: is_source_job__.unwrap_or_default(),
4087                    is_backfill_table: is_backfill_table__.unwrap_or_default(),
4088                })
4089            }
4090        }
4091        deserializer.deserialize_struct("connector_service.ValidateSourceRequest", FIELDS, GeneratedVisitor)
4092    }
4093}
4094impl serde::Serialize for ValidateSourceResponse {
4095    #[allow(deprecated)]
4096    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4097    where
4098        S: serde::Serializer,
4099    {
4100        use serde::ser::SerializeStruct;
4101        let mut len = 0;
4102        if self.error.is_some() {
4103            len += 1;
4104        }
4105        let mut struct_ser = serializer.serialize_struct("connector_service.ValidateSourceResponse", len)?;
4106        if let Some(v) = self.error.as_ref() {
4107            struct_ser.serialize_field("error", v)?;
4108        }
4109        struct_ser.end()
4110    }
4111}
4112impl<'de> serde::Deserialize<'de> for ValidateSourceResponse {
4113    #[allow(deprecated)]
4114    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4115    where
4116        D: serde::Deserializer<'de>,
4117    {
4118        const FIELDS: &[&str] = &[
4119            "error",
4120        ];
4121
4122        #[allow(clippy::enum_variant_names)]
4123        enum GeneratedField {
4124            Error,
4125        }
4126        impl<'de> serde::Deserialize<'de> for GeneratedField {
4127            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4128            where
4129                D: serde::Deserializer<'de>,
4130            {
4131                struct GeneratedVisitor;
4132
4133                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4134                    type Value = GeneratedField;
4135
4136                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4137                        write!(formatter, "expected one of: {:?}", &FIELDS)
4138                    }
4139
4140                    #[allow(unused_variables)]
4141                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4142                    where
4143                        E: serde::de::Error,
4144                    {
4145                        match value {
4146                            "error" => Ok(GeneratedField::Error),
4147                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4148                        }
4149                    }
4150                }
4151                deserializer.deserialize_identifier(GeneratedVisitor)
4152            }
4153        }
4154        struct GeneratedVisitor;
4155        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4156            type Value = ValidateSourceResponse;
4157
4158            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4159                formatter.write_str("struct connector_service.ValidateSourceResponse")
4160            }
4161
4162            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidateSourceResponse, V::Error>
4163                where
4164                    V: serde::de::MapAccess<'de>,
4165            {
4166                let mut error__ = None;
4167                while let Some(k) = map_.next_key()? {
4168                    match k {
4169                        GeneratedField::Error => {
4170                            if error__.is_some() {
4171                                return Err(serde::de::Error::duplicate_field("error"));
4172                            }
4173                            error__ = map_.next_value()?;
4174                        }
4175                    }
4176                }
4177                Ok(ValidateSourceResponse {
4178                    error: error__,
4179                })
4180            }
4181        }
4182        deserializer.deserialize_struct("connector_service.ValidateSourceResponse", FIELDS, GeneratedVisitor)
4183    }
4184}
4185impl serde::Serialize for ValidationError {
4186    #[allow(deprecated)]
4187    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4188    where
4189        S: serde::Serializer,
4190    {
4191        use serde::ser::SerializeStruct;
4192        let mut len = 0;
4193        if !self.error_message.is_empty() {
4194            len += 1;
4195        }
4196        let mut struct_ser = serializer.serialize_struct("connector_service.ValidationError", len)?;
4197        if !self.error_message.is_empty() {
4198            struct_ser.serialize_field("errorMessage", &self.error_message)?;
4199        }
4200        struct_ser.end()
4201    }
4202}
4203impl<'de> serde::Deserialize<'de> for ValidationError {
4204    #[allow(deprecated)]
4205    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4206    where
4207        D: serde::Deserializer<'de>,
4208    {
4209        const FIELDS: &[&str] = &[
4210            "error_message",
4211            "errorMessage",
4212        ];
4213
4214        #[allow(clippy::enum_variant_names)]
4215        enum GeneratedField {
4216            ErrorMessage,
4217        }
4218        impl<'de> serde::Deserialize<'de> for GeneratedField {
4219            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4220            where
4221                D: serde::Deserializer<'de>,
4222            {
4223                struct GeneratedVisitor;
4224
4225                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4226                    type Value = GeneratedField;
4227
4228                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4229                        write!(formatter, "expected one of: {:?}", &FIELDS)
4230                    }
4231
4232                    #[allow(unused_variables)]
4233                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4234                    where
4235                        E: serde::de::Error,
4236                    {
4237                        match value {
4238                            "errorMessage" | "error_message" => Ok(GeneratedField::ErrorMessage),
4239                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4240                        }
4241                    }
4242                }
4243                deserializer.deserialize_identifier(GeneratedVisitor)
4244            }
4245        }
4246        struct GeneratedVisitor;
4247        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4248            type Value = ValidationError;
4249
4250            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4251                formatter.write_str("struct connector_service.ValidationError")
4252            }
4253
4254            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValidationError, V::Error>
4255                where
4256                    V: serde::de::MapAccess<'de>,
4257            {
4258                let mut error_message__ = None;
4259                while let Some(k) = map_.next_key()? {
4260                    match k {
4261                        GeneratedField::ErrorMessage => {
4262                            if error_message__.is_some() {
4263                                return Err(serde::de::Error::duplicate_field("errorMessage"));
4264                            }
4265                            error_message__ = Some(map_.next_value()?);
4266                        }
4267                    }
4268                }
4269                Ok(ValidationError {
4270                    error_message: error_message__.unwrap_or_default(),
4271                })
4272            }
4273        }
4274        deserializer.deserialize_struct("connector_service.ValidationError", FIELDS, GeneratedVisitor)
4275    }
4276}