risingwave_pb/
stream_plan.serde.rs

1use crate::stream_plan::*;
2impl serde::Serialize for ActorMapping {
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.original_indices.is_empty() {
11            len += 1;
12        }
13        if !self.data.is_empty() {
14            len += 1;
15        }
16        let mut struct_ser = serializer.serialize_struct("stream_plan.ActorMapping", len)?;
17        if !self.original_indices.is_empty() {
18            struct_ser.serialize_field("originalIndices", &self.original_indices)?;
19        }
20        if !self.data.is_empty() {
21            struct_ser.serialize_field("data", &self.data)?;
22        }
23        struct_ser.end()
24    }
25}
26impl<'de> serde::Deserialize<'de> for ActorMapping {
27    #[allow(deprecated)]
28    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
29    where
30        D: serde::Deserializer<'de>,
31    {
32        const FIELDS: &[&str] = &[
33            "original_indices",
34            "originalIndices",
35            "data",
36        ];
37
38        #[allow(clippy::enum_variant_names)]
39        enum GeneratedField {
40            OriginalIndices,
41            Data,
42        }
43        impl<'de> serde::Deserialize<'de> for GeneratedField {
44            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
45            where
46                D: serde::Deserializer<'de>,
47            {
48                struct GeneratedVisitor;
49
50                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
51                    type Value = GeneratedField;
52
53                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
54                        write!(formatter, "expected one of: {:?}", &FIELDS)
55                    }
56
57                    #[allow(unused_variables)]
58                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
59                    where
60                        E: serde::de::Error,
61                    {
62                        match value {
63                            "originalIndices" | "original_indices" => Ok(GeneratedField::OriginalIndices),
64                            "data" => Ok(GeneratedField::Data),
65                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
66                        }
67                    }
68                }
69                deserializer.deserialize_identifier(GeneratedVisitor)
70            }
71        }
72        struct GeneratedVisitor;
73        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
74            type Value = ActorMapping;
75
76            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
77                formatter.write_str("struct stream_plan.ActorMapping")
78            }
79
80            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ActorMapping, V::Error>
81                where
82                    V: serde::de::MapAccess<'de>,
83            {
84                let mut original_indices__ = None;
85                let mut data__ = None;
86                while let Some(k) = map_.next_key()? {
87                    match k {
88                        GeneratedField::OriginalIndices => {
89                            if original_indices__.is_some() {
90                                return Err(serde::de::Error::duplicate_field("originalIndices"));
91                            }
92                            original_indices__ = 
93                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
94                                    .into_iter().map(|x| x.0).collect())
95                            ;
96                        }
97                        GeneratedField::Data => {
98                            if data__.is_some() {
99                                return Err(serde::de::Error::duplicate_field("data"));
100                            }
101                            data__ = 
102                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
103                                    .into_iter().map(|x| x.0).collect())
104                            ;
105                        }
106                    }
107                }
108                Ok(ActorMapping {
109                    original_indices: original_indices__.unwrap_or_default(),
110                    data: data__.unwrap_or_default(),
111                })
112            }
113        }
114        deserializer.deserialize_struct("stream_plan.ActorMapping", FIELDS, GeneratedVisitor)
115    }
116}
117impl serde::Serialize for AddMutation {
118    #[allow(deprecated)]
119    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
120    where
121        S: serde::Serializer,
122    {
123        use serde::ser::SerializeStruct;
124        let mut len = 0;
125        if !self.actor_dispatchers.is_empty() {
126            len += 1;
127        }
128        if !self.added_actors.is_empty() {
129            len += 1;
130        }
131        if !self.actor_splits.is_empty() {
132            len += 1;
133        }
134        if self.pause {
135            len += 1;
136        }
137        if !self.subscriptions_to_add.is_empty() {
138            len += 1;
139        }
140        if !self.backfill_nodes_to_pause.is_empty() {
141            len += 1;
142        }
143        let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation", len)?;
144        if !self.actor_dispatchers.is_empty() {
145            struct_ser.serialize_field("actorDispatchers", &self.actor_dispatchers)?;
146        }
147        if !self.added_actors.is_empty() {
148            struct_ser.serialize_field("addedActors", &self.added_actors)?;
149        }
150        if !self.actor_splits.is_empty() {
151            struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
152        }
153        if self.pause {
154            struct_ser.serialize_field("pause", &self.pause)?;
155        }
156        if !self.subscriptions_to_add.is_empty() {
157            struct_ser.serialize_field("subscriptionsToAdd", &self.subscriptions_to_add)?;
158        }
159        if !self.backfill_nodes_to_pause.is_empty() {
160            struct_ser.serialize_field("backfillNodesToPause", &self.backfill_nodes_to_pause)?;
161        }
162        struct_ser.end()
163    }
164}
165impl<'de> serde::Deserialize<'de> for AddMutation {
166    #[allow(deprecated)]
167    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
168    where
169        D: serde::Deserializer<'de>,
170    {
171        const FIELDS: &[&str] = &[
172            "actor_dispatchers",
173            "actorDispatchers",
174            "added_actors",
175            "addedActors",
176            "actor_splits",
177            "actorSplits",
178            "pause",
179            "subscriptions_to_add",
180            "subscriptionsToAdd",
181            "backfill_nodes_to_pause",
182            "backfillNodesToPause",
183        ];
184
185        #[allow(clippy::enum_variant_names)]
186        enum GeneratedField {
187            ActorDispatchers,
188            AddedActors,
189            ActorSplits,
190            Pause,
191            SubscriptionsToAdd,
192            BackfillNodesToPause,
193        }
194        impl<'de> serde::Deserialize<'de> for GeneratedField {
195            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
196            where
197                D: serde::Deserializer<'de>,
198            {
199                struct GeneratedVisitor;
200
201                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
202                    type Value = GeneratedField;
203
204                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
205                        write!(formatter, "expected one of: {:?}", &FIELDS)
206                    }
207
208                    #[allow(unused_variables)]
209                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
210                    where
211                        E: serde::de::Error,
212                    {
213                        match value {
214                            "actorDispatchers" | "actor_dispatchers" => Ok(GeneratedField::ActorDispatchers),
215                            "addedActors" | "added_actors" => Ok(GeneratedField::AddedActors),
216                            "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
217                            "pause" => Ok(GeneratedField::Pause),
218                            "subscriptionsToAdd" | "subscriptions_to_add" => Ok(GeneratedField::SubscriptionsToAdd),
219                            "backfillNodesToPause" | "backfill_nodes_to_pause" => Ok(GeneratedField::BackfillNodesToPause),
220                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
221                        }
222                    }
223                }
224                deserializer.deserialize_identifier(GeneratedVisitor)
225            }
226        }
227        struct GeneratedVisitor;
228        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
229            type Value = AddMutation;
230
231            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
232                formatter.write_str("struct stream_plan.AddMutation")
233            }
234
235            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddMutation, V::Error>
236                where
237                    V: serde::de::MapAccess<'de>,
238            {
239                let mut actor_dispatchers__ = None;
240                let mut added_actors__ = None;
241                let mut actor_splits__ = None;
242                let mut pause__ = None;
243                let mut subscriptions_to_add__ = None;
244                let mut backfill_nodes_to_pause__ = None;
245                while let Some(k) = map_.next_key()? {
246                    match k {
247                        GeneratedField::ActorDispatchers => {
248                            if actor_dispatchers__.is_some() {
249                                return Err(serde::de::Error::duplicate_field("actorDispatchers"));
250                            }
251                            actor_dispatchers__ = Some(
252                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
253                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
254                            );
255                        }
256                        GeneratedField::AddedActors => {
257                            if added_actors__.is_some() {
258                                return Err(serde::de::Error::duplicate_field("addedActors"));
259                            }
260                            added_actors__ = 
261                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
262                                    .into_iter().map(|x| x.0).collect())
263                            ;
264                        }
265                        GeneratedField::ActorSplits => {
266                            if actor_splits__.is_some() {
267                                return Err(serde::de::Error::duplicate_field("actorSplits"));
268                            }
269                            actor_splits__ = Some(
270                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
271                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
272                            );
273                        }
274                        GeneratedField::Pause => {
275                            if pause__.is_some() {
276                                return Err(serde::de::Error::duplicate_field("pause"));
277                            }
278                            pause__ = Some(map_.next_value()?);
279                        }
280                        GeneratedField::SubscriptionsToAdd => {
281                            if subscriptions_to_add__.is_some() {
282                                return Err(serde::de::Error::duplicate_field("subscriptionsToAdd"));
283                            }
284                            subscriptions_to_add__ = Some(map_.next_value()?);
285                        }
286                        GeneratedField::BackfillNodesToPause => {
287                            if backfill_nodes_to_pause__.is_some() {
288                                return Err(serde::de::Error::duplicate_field("backfillNodesToPause"));
289                            }
290                            backfill_nodes_to_pause__ = 
291                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
292                                    .into_iter().map(|x| x.0).collect())
293                            ;
294                        }
295                    }
296                }
297                Ok(AddMutation {
298                    actor_dispatchers: actor_dispatchers__.unwrap_or_default(),
299                    added_actors: added_actors__.unwrap_or_default(),
300                    actor_splits: actor_splits__.unwrap_or_default(),
301                    pause: pause__.unwrap_or_default(),
302                    subscriptions_to_add: subscriptions_to_add__.unwrap_or_default(),
303                    backfill_nodes_to_pause: backfill_nodes_to_pause__.unwrap_or_default(),
304                })
305            }
306        }
307        deserializer.deserialize_struct("stream_plan.AddMutation", FIELDS, GeneratedVisitor)
308    }
309}
310impl serde::Serialize for AggCallState {
311    #[allow(deprecated)]
312    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
313    where
314        S: serde::Serializer,
315    {
316        use serde::ser::SerializeStruct;
317        let mut len = 0;
318        if self.inner.is_some() {
319            len += 1;
320        }
321        let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState", len)?;
322        if let Some(v) = self.inner.as_ref() {
323            match v {
324                agg_call_state::Inner::ValueState(v) => {
325                    struct_ser.serialize_field("valueState", v)?;
326                }
327                agg_call_state::Inner::MaterializedInputState(v) => {
328                    struct_ser.serialize_field("materializedInputState", v)?;
329                }
330            }
331        }
332        struct_ser.end()
333    }
334}
335impl<'de> serde::Deserialize<'de> for AggCallState {
336    #[allow(deprecated)]
337    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
338    where
339        D: serde::Deserializer<'de>,
340    {
341        const FIELDS: &[&str] = &[
342            "value_state",
343            "valueState",
344            "materialized_input_state",
345            "materializedInputState",
346        ];
347
348        #[allow(clippy::enum_variant_names)]
349        enum GeneratedField {
350            ValueState,
351            MaterializedInputState,
352        }
353        impl<'de> serde::Deserialize<'de> for GeneratedField {
354            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
355            where
356                D: serde::Deserializer<'de>,
357            {
358                struct GeneratedVisitor;
359
360                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
361                    type Value = GeneratedField;
362
363                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
364                        write!(formatter, "expected one of: {:?}", &FIELDS)
365                    }
366
367                    #[allow(unused_variables)]
368                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
369                    where
370                        E: serde::de::Error,
371                    {
372                        match value {
373                            "valueState" | "value_state" => Ok(GeneratedField::ValueState),
374                            "materializedInputState" | "materialized_input_state" => Ok(GeneratedField::MaterializedInputState),
375                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
376                        }
377                    }
378                }
379                deserializer.deserialize_identifier(GeneratedVisitor)
380            }
381        }
382        struct GeneratedVisitor;
383        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
384            type Value = AggCallState;
385
386            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
387                formatter.write_str("struct stream_plan.AggCallState")
388            }
389
390            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AggCallState, V::Error>
391                where
392                    V: serde::de::MapAccess<'de>,
393            {
394                let mut inner__ = None;
395                while let Some(k) = map_.next_key()? {
396                    match k {
397                        GeneratedField::ValueState => {
398                            if inner__.is_some() {
399                                return Err(serde::de::Error::duplicate_field("valueState"));
400                            }
401                            inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::ValueState)
402;
403                        }
404                        GeneratedField::MaterializedInputState => {
405                            if inner__.is_some() {
406                                return Err(serde::de::Error::duplicate_field("materializedInputState"));
407                            }
408                            inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::MaterializedInputState)
409;
410                        }
411                    }
412                }
413                Ok(AggCallState {
414                    inner: inner__,
415                })
416            }
417        }
418        deserializer.deserialize_struct("stream_plan.AggCallState", FIELDS, GeneratedVisitor)
419    }
420}
421impl serde::Serialize for agg_call_state::MaterializedInputState {
422    #[allow(deprecated)]
423    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
424    where
425        S: serde::Serializer,
426    {
427        use serde::ser::SerializeStruct;
428        let mut len = 0;
429        if self.table.is_some() {
430            len += 1;
431        }
432        if !self.included_upstream_indices.is_empty() {
433            len += 1;
434        }
435        if !self.table_value_indices.is_empty() {
436            len += 1;
437        }
438        if !self.order_columns.is_empty() {
439            len += 1;
440        }
441        let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState.MaterializedInputState", len)?;
442        if let Some(v) = self.table.as_ref() {
443            struct_ser.serialize_field("table", v)?;
444        }
445        if !self.included_upstream_indices.is_empty() {
446            struct_ser.serialize_field("includedUpstreamIndices", &self.included_upstream_indices)?;
447        }
448        if !self.table_value_indices.is_empty() {
449            struct_ser.serialize_field("tableValueIndices", &self.table_value_indices)?;
450        }
451        if !self.order_columns.is_empty() {
452            struct_ser.serialize_field("orderColumns", &self.order_columns)?;
453        }
454        struct_ser.end()
455    }
456}
457impl<'de> serde::Deserialize<'de> for agg_call_state::MaterializedInputState {
458    #[allow(deprecated)]
459    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
460    where
461        D: serde::Deserializer<'de>,
462    {
463        const FIELDS: &[&str] = &[
464            "table",
465            "included_upstream_indices",
466            "includedUpstreamIndices",
467            "table_value_indices",
468            "tableValueIndices",
469            "order_columns",
470            "orderColumns",
471        ];
472
473        #[allow(clippy::enum_variant_names)]
474        enum GeneratedField {
475            Table,
476            IncludedUpstreamIndices,
477            TableValueIndices,
478            OrderColumns,
479        }
480        impl<'de> serde::Deserialize<'de> for GeneratedField {
481            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
482            where
483                D: serde::Deserializer<'de>,
484            {
485                struct GeneratedVisitor;
486
487                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
488                    type Value = GeneratedField;
489
490                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
491                        write!(formatter, "expected one of: {:?}", &FIELDS)
492                    }
493
494                    #[allow(unused_variables)]
495                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
496                    where
497                        E: serde::de::Error,
498                    {
499                        match value {
500                            "table" => Ok(GeneratedField::Table),
501                            "includedUpstreamIndices" | "included_upstream_indices" => Ok(GeneratedField::IncludedUpstreamIndices),
502                            "tableValueIndices" | "table_value_indices" => Ok(GeneratedField::TableValueIndices),
503                            "orderColumns" | "order_columns" => Ok(GeneratedField::OrderColumns),
504                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
505                        }
506                    }
507                }
508                deserializer.deserialize_identifier(GeneratedVisitor)
509            }
510        }
511        struct GeneratedVisitor;
512        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
513            type Value = agg_call_state::MaterializedInputState;
514
515            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
516                formatter.write_str("struct stream_plan.AggCallState.MaterializedInputState")
517            }
518
519            fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::MaterializedInputState, V::Error>
520                where
521                    V: serde::de::MapAccess<'de>,
522            {
523                let mut table__ = None;
524                let mut included_upstream_indices__ = None;
525                let mut table_value_indices__ = None;
526                let mut order_columns__ = None;
527                while let Some(k) = map_.next_key()? {
528                    match k {
529                        GeneratedField::Table => {
530                            if table__.is_some() {
531                                return Err(serde::de::Error::duplicate_field("table"));
532                            }
533                            table__ = map_.next_value()?;
534                        }
535                        GeneratedField::IncludedUpstreamIndices => {
536                            if included_upstream_indices__.is_some() {
537                                return Err(serde::de::Error::duplicate_field("includedUpstreamIndices"));
538                            }
539                            included_upstream_indices__ = 
540                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
541                                    .into_iter().map(|x| x.0).collect())
542                            ;
543                        }
544                        GeneratedField::TableValueIndices => {
545                            if table_value_indices__.is_some() {
546                                return Err(serde::de::Error::duplicate_field("tableValueIndices"));
547                            }
548                            table_value_indices__ = 
549                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
550                                    .into_iter().map(|x| x.0).collect())
551                            ;
552                        }
553                        GeneratedField::OrderColumns => {
554                            if order_columns__.is_some() {
555                                return Err(serde::de::Error::duplicate_field("orderColumns"));
556                            }
557                            order_columns__ = Some(map_.next_value()?);
558                        }
559                    }
560                }
561                Ok(agg_call_state::MaterializedInputState {
562                    table: table__,
563                    included_upstream_indices: included_upstream_indices__.unwrap_or_default(),
564                    table_value_indices: table_value_indices__.unwrap_or_default(),
565                    order_columns: order_columns__.unwrap_or_default(),
566                })
567            }
568        }
569        deserializer.deserialize_struct("stream_plan.AggCallState.MaterializedInputState", FIELDS, GeneratedVisitor)
570    }
571}
572impl serde::Serialize for agg_call_state::ValueState {
573    #[allow(deprecated)]
574    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
575    where
576        S: serde::Serializer,
577    {
578        use serde::ser::SerializeStruct;
579        let len = 0;
580        let struct_ser = serializer.serialize_struct("stream_plan.AggCallState.ValueState", len)?;
581        struct_ser.end()
582    }
583}
584impl<'de> serde::Deserialize<'de> for agg_call_state::ValueState {
585    #[allow(deprecated)]
586    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
587    where
588        D: serde::Deserializer<'de>,
589    {
590        const FIELDS: &[&str] = &[
591        ];
592
593        #[allow(clippy::enum_variant_names)]
594        enum GeneratedField {
595        }
596        impl<'de> serde::Deserialize<'de> for GeneratedField {
597            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
598            where
599                D: serde::Deserializer<'de>,
600            {
601                struct GeneratedVisitor;
602
603                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
604                    type Value = GeneratedField;
605
606                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
607                        write!(formatter, "expected one of: {:?}", &FIELDS)
608                    }
609
610                    #[allow(unused_variables)]
611                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
612                    where
613                        E: serde::de::Error,
614                    {
615                            Err(serde::de::Error::unknown_field(value, FIELDS))
616                    }
617                }
618                deserializer.deserialize_identifier(GeneratedVisitor)
619            }
620        }
621        struct GeneratedVisitor;
622        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
623            type Value = agg_call_state::ValueState;
624
625            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
626                formatter.write_str("struct stream_plan.AggCallState.ValueState")
627            }
628
629            fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::ValueState, V::Error>
630                where
631                    V: serde::de::MapAccess<'de>,
632            {
633                while map_.next_key::<GeneratedField>()?.is_some() {
634                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
635                }
636                Ok(agg_call_state::ValueState {
637                })
638            }
639        }
640        deserializer.deserialize_struct("stream_plan.AggCallState.ValueState", FIELDS, GeneratedVisitor)
641    }
642}
643impl serde::Serialize for AggNodeVersion {
644    #[allow(deprecated)]
645    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
646    where
647        S: serde::Serializer,
648    {
649        let variant = match self {
650            Self::Unspecified => "AGG_NODE_VERSION_UNSPECIFIED",
651            Self::Issue12140 => "AGG_NODE_VERSION_ISSUE_12140",
652            Self::Issue13465 => "AGG_NODE_VERSION_ISSUE_13465",
653        };
654        serializer.serialize_str(variant)
655    }
656}
657impl<'de> serde::Deserialize<'de> for AggNodeVersion {
658    #[allow(deprecated)]
659    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
660    where
661        D: serde::Deserializer<'de>,
662    {
663        const FIELDS: &[&str] = &[
664            "AGG_NODE_VERSION_UNSPECIFIED",
665            "AGG_NODE_VERSION_ISSUE_12140",
666            "AGG_NODE_VERSION_ISSUE_13465",
667        ];
668
669        struct GeneratedVisitor;
670
671        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
672            type Value = AggNodeVersion;
673
674            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
675                write!(formatter, "expected one of: {:?}", &FIELDS)
676            }
677
678            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
679            where
680                E: serde::de::Error,
681            {
682                i32::try_from(v)
683                    .ok()
684                    .and_then(|x| x.try_into().ok())
685                    .ok_or_else(|| {
686                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
687                    })
688            }
689
690            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
691            where
692                E: serde::de::Error,
693            {
694                i32::try_from(v)
695                    .ok()
696                    .and_then(|x| x.try_into().ok())
697                    .ok_or_else(|| {
698                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
699                    })
700            }
701
702            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
703            where
704                E: serde::de::Error,
705            {
706                match value {
707                    "AGG_NODE_VERSION_UNSPECIFIED" => Ok(AggNodeVersion::Unspecified),
708                    "AGG_NODE_VERSION_ISSUE_12140" => Ok(AggNodeVersion::Issue12140),
709                    "AGG_NODE_VERSION_ISSUE_13465" => Ok(AggNodeVersion::Issue13465),
710                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
711                }
712            }
713        }
714        deserializer.deserialize_any(GeneratedVisitor)
715    }
716}
717impl serde::Serialize for ArrangeNode {
718    #[allow(deprecated)]
719    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
720    where
721        S: serde::Serializer,
722    {
723        use serde::ser::SerializeStruct;
724        let mut len = 0;
725        if self.table_info.is_some() {
726            len += 1;
727        }
728        if !self.distribution_key.is_empty() {
729            len += 1;
730        }
731        if self.table.is_some() {
732            len += 1;
733        }
734        let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangeNode", len)?;
735        if let Some(v) = self.table_info.as_ref() {
736            struct_ser.serialize_field("tableInfo", v)?;
737        }
738        if !self.distribution_key.is_empty() {
739            struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
740        }
741        if let Some(v) = self.table.as_ref() {
742            struct_ser.serialize_field("table", v)?;
743        }
744        struct_ser.end()
745    }
746}
747impl<'de> serde::Deserialize<'de> for ArrangeNode {
748    #[allow(deprecated)]
749    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
750    where
751        D: serde::Deserializer<'de>,
752    {
753        const FIELDS: &[&str] = &[
754            "table_info",
755            "tableInfo",
756            "distribution_key",
757            "distributionKey",
758            "table",
759        ];
760
761        #[allow(clippy::enum_variant_names)]
762        enum GeneratedField {
763            TableInfo,
764            DistributionKey,
765            Table,
766        }
767        impl<'de> serde::Deserialize<'de> for GeneratedField {
768            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
769            where
770                D: serde::Deserializer<'de>,
771            {
772                struct GeneratedVisitor;
773
774                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
775                    type Value = GeneratedField;
776
777                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
778                        write!(formatter, "expected one of: {:?}", &FIELDS)
779                    }
780
781                    #[allow(unused_variables)]
782                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
783                    where
784                        E: serde::de::Error,
785                    {
786                        match value {
787                            "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
788                            "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
789                            "table" => Ok(GeneratedField::Table),
790                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
791                        }
792                    }
793                }
794                deserializer.deserialize_identifier(GeneratedVisitor)
795            }
796        }
797        struct GeneratedVisitor;
798        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
799            type Value = ArrangeNode;
800
801            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
802                formatter.write_str("struct stream_plan.ArrangeNode")
803            }
804
805            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangeNode, V::Error>
806                where
807                    V: serde::de::MapAccess<'de>,
808            {
809                let mut table_info__ = None;
810                let mut distribution_key__ = None;
811                let mut table__ = None;
812                while let Some(k) = map_.next_key()? {
813                    match k {
814                        GeneratedField::TableInfo => {
815                            if table_info__.is_some() {
816                                return Err(serde::de::Error::duplicate_field("tableInfo"));
817                            }
818                            table_info__ = map_.next_value()?;
819                        }
820                        GeneratedField::DistributionKey => {
821                            if distribution_key__.is_some() {
822                                return Err(serde::de::Error::duplicate_field("distributionKey"));
823                            }
824                            distribution_key__ = 
825                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
826                                    .into_iter().map(|x| x.0).collect())
827                            ;
828                        }
829                        GeneratedField::Table => {
830                            if table__.is_some() {
831                                return Err(serde::de::Error::duplicate_field("table"));
832                            }
833                            table__ = map_.next_value()?;
834                        }
835                    }
836                }
837                Ok(ArrangeNode {
838                    table_info: table_info__,
839                    distribution_key: distribution_key__.unwrap_or_default(),
840                    table: table__,
841                })
842            }
843        }
844        deserializer.deserialize_struct("stream_plan.ArrangeNode", FIELDS, GeneratedVisitor)
845    }
846}
847impl serde::Serialize for ArrangementInfo {
848    #[allow(deprecated)]
849    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
850    where
851        S: serde::Serializer,
852    {
853        use serde::ser::SerializeStruct;
854        let mut len = 0;
855        if !self.arrange_key_orders.is_empty() {
856            len += 1;
857        }
858        if !self.column_descs.is_empty() {
859            len += 1;
860        }
861        if self.table_desc.is_some() {
862            len += 1;
863        }
864        if !self.output_col_idx.is_empty() {
865            len += 1;
866        }
867        let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangementInfo", len)?;
868        if !self.arrange_key_orders.is_empty() {
869            struct_ser.serialize_field("arrangeKeyOrders", &self.arrange_key_orders)?;
870        }
871        if !self.column_descs.is_empty() {
872            struct_ser.serialize_field("columnDescs", &self.column_descs)?;
873        }
874        if let Some(v) = self.table_desc.as_ref() {
875            struct_ser.serialize_field("tableDesc", v)?;
876        }
877        if !self.output_col_idx.is_empty() {
878            struct_ser.serialize_field("outputColIdx", &self.output_col_idx)?;
879        }
880        struct_ser.end()
881    }
882}
883impl<'de> serde::Deserialize<'de> for ArrangementInfo {
884    #[allow(deprecated)]
885    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
886    where
887        D: serde::Deserializer<'de>,
888    {
889        const FIELDS: &[&str] = &[
890            "arrange_key_orders",
891            "arrangeKeyOrders",
892            "column_descs",
893            "columnDescs",
894            "table_desc",
895            "tableDesc",
896            "output_col_idx",
897            "outputColIdx",
898        ];
899
900        #[allow(clippy::enum_variant_names)]
901        enum GeneratedField {
902            ArrangeKeyOrders,
903            ColumnDescs,
904            TableDesc,
905            OutputColIdx,
906        }
907        impl<'de> serde::Deserialize<'de> for GeneratedField {
908            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
909            where
910                D: serde::Deserializer<'de>,
911            {
912                struct GeneratedVisitor;
913
914                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
915                    type Value = GeneratedField;
916
917                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
918                        write!(formatter, "expected one of: {:?}", &FIELDS)
919                    }
920
921                    #[allow(unused_variables)]
922                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
923                    where
924                        E: serde::de::Error,
925                    {
926                        match value {
927                            "arrangeKeyOrders" | "arrange_key_orders" => Ok(GeneratedField::ArrangeKeyOrders),
928                            "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
929                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
930                            "outputColIdx" | "output_col_idx" => Ok(GeneratedField::OutputColIdx),
931                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
932                        }
933                    }
934                }
935                deserializer.deserialize_identifier(GeneratedVisitor)
936            }
937        }
938        struct GeneratedVisitor;
939        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
940            type Value = ArrangementInfo;
941
942            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
943                formatter.write_str("struct stream_plan.ArrangementInfo")
944            }
945
946            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangementInfo, V::Error>
947                where
948                    V: serde::de::MapAccess<'de>,
949            {
950                let mut arrange_key_orders__ = None;
951                let mut column_descs__ = None;
952                let mut table_desc__ = None;
953                let mut output_col_idx__ = None;
954                while let Some(k) = map_.next_key()? {
955                    match k {
956                        GeneratedField::ArrangeKeyOrders => {
957                            if arrange_key_orders__.is_some() {
958                                return Err(serde::de::Error::duplicate_field("arrangeKeyOrders"));
959                            }
960                            arrange_key_orders__ = Some(map_.next_value()?);
961                        }
962                        GeneratedField::ColumnDescs => {
963                            if column_descs__.is_some() {
964                                return Err(serde::de::Error::duplicate_field("columnDescs"));
965                            }
966                            column_descs__ = Some(map_.next_value()?);
967                        }
968                        GeneratedField::TableDesc => {
969                            if table_desc__.is_some() {
970                                return Err(serde::de::Error::duplicate_field("tableDesc"));
971                            }
972                            table_desc__ = map_.next_value()?;
973                        }
974                        GeneratedField::OutputColIdx => {
975                            if output_col_idx__.is_some() {
976                                return Err(serde::de::Error::duplicate_field("outputColIdx"));
977                            }
978                            output_col_idx__ = 
979                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
980                                    .into_iter().map(|x| x.0).collect())
981                            ;
982                        }
983                    }
984                }
985                Ok(ArrangementInfo {
986                    arrange_key_orders: arrange_key_orders__.unwrap_or_default(),
987                    column_descs: column_descs__.unwrap_or_default(),
988                    table_desc: table_desc__,
989                    output_col_idx: output_col_idx__.unwrap_or_default(),
990                })
991            }
992        }
993        deserializer.deserialize_struct("stream_plan.ArrangementInfo", FIELDS, GeneratedVisitor)
994    }
995}
996impl serde::Serialize for AsOfJoinNode {
997    #[allow(deprecated)]
998    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
999    where
1000        S: serde::Serializer,
1001    {
1002        use serde::ser::SerializeStruct;
1003        let mut len = 0;
1004        if self.join_type != 0 {
1005            len += 1;
1006        }
1007        if !self.left_key.is_empty() {
1008            len += 1;
1009        }
1010        if !self.right_key.is_empty() {
1011            len += 1;
1012        }
1013        if self.left_table.is_some() {
1014            len += 1;
1015        }
1016        if self.right_table.is_some() {
1017            len += 1;
1018        }
1019        if !self.output_indices.is_empty() {
1020            len += 1;
1021        }
1022        if !self.left_deduped_input_pk_indices.is_empty() {
1023            len += 1;
1024        }
1025        if !self.right_deduped_input_pk_indices.is_empty() {
1026            len += 1;
1027        }
1028        if !self.null_safe.is_empty() {
1029            len += 1;
1030        }
1031        if self.asof_desc.is_some() {
1032            len += 1;
1033        }
1034        if self.join_encoding_type != 0 {
1035            len += 1;
1036        }
1037        let mut struct_ser = serializer.serialize_struct("stream_plan.AsOfJoinNode", len)?;
1038        if self.join_type != 0 {
1039            let v = super::plan_common::AsOfJoinType::try_from(self.join_type)
1040                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
1041            struct_ser.serialize_field("joinType", &v)?;
1042        }
1043        if !self.left_key.is_empty() {
1044            struct_ser.serialize_field("leftKey", &self.left_key)?;
1045        }
1046        if !self.right_key.is_empty() {
1047            struct_ser.serialize_field("rightKey", &self.right_key)?;
1048        }
1049        if let Some(v) = self.left_table.as_ref() {
1050            struct_ser.serialize_field("leftTable", v)?;
1051        }
1052        if let Some(v) = self.right_table.as_ref() {
1053            struct_ser.serialize_field("rightTable", v)?;
1054        }
1055        if !self.output_indices.is_empty() {
1056            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
1057        }
1058        if !self.left_deduped_input_pk_indices.is_empty() {
1059            struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
1060        }
1061        if !self.right_deduped_input_pk_indices.is_empty() {
1062            struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
1063        }
1064        if !self.null_safe.is_empty() {
1065            struct_ser.serialize_field("nullSafe", &self.null_safe)?;
1066        }
1067        if let Some(v) = self.asof_desc.as_ref() {
1068            struct_ser.serialize_field("asofDesc", v)?;
1069        }
1070        if self.join_encoding_type != 0 {
1071            let v = JoinEncodingType::try_from(self.join_encoding_type)
1072                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
1073            struct_ser.serialize_field("joinEncodingType", &v)?;
1074        }
1075        struct_ser.end()
1076    }
1077}
1078impl<'de> serde::Deserialize<'de> for AsOfJoinNode {
1079    #[allow(deprecated)]
1080    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1081    where
1082        D: serde::Deserializer<'de>,
1083    {
1084        const FIELDS: &[&str] = &[
1085            "join_type",
1086            "joinType",
1087            "left_key",
1088            "leftKey",
1089            "right_key",
1090            "rightKey",
1091            "left_table",
1092            "leftTable",
1093            "right_table",
1094            "rightTable",
1095            "output_indices",
1096            "outputIndices",
1097            "left_deduped_input_pk_indices",
1098            "leftDedupedInputPkIndices",
1099            "right_deduped_input_pk_indices",
1100            "rightDedupedInputPkIndices",
1101            "null_safe",
1102            "nullSafe",
1103            "asof_desc",
1104            "asofDesc",
1105            "join_encoding_type",
1106            "joinEncodingType",
1107        ];
1108
1109        #[allow(clippy::enum_variant_names)]
1110        enum GeneratedField {
1111            JoinType,
1112            LeftKey,
1113            RightKey,
1114            LeftTable,
1115            RightTable,
1116            OutputIndices,
1117            LeftDedupedInputPkIndices,
1118            RightDedupedInputPkIndices,
1119            NullSafe,
1120            AsofDesc,
1121            JoinEncodingType,
1122        }
1123        impl<'de> serde::Deserialize<'de> for GeneratedField {
1124            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1125            where
1126                D: serde::Deserializer<'de>,
1127            {
1128                struct GeneratedVisitor;
1129
1130                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1131                    type Value = GeneratedField;
1132
1133                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1134                        write!(formatter, "expected one of: {:?}", &FIELDS)
1135                    }
1136
1137                    #[allow(unused_variables)]
1138                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1139                    where
1140                        E: serde::de::Error,
1141                    {
1142                        match value {
1143                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
1144                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
1145                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
1146                            "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
1147                            "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
1148                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
1149                            "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
1150                            "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
1151                            "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
1152                            "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
1153                            "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
1154                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1155                        }
1156                    }
1157                }
1158                deserializer.deserialize_identifier(GeneratedVisitor)
1159            }
1160        }
1161        struct GeneratedVisitor;
1162        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1163            type Value = AsOfJoinNode;
1164
1165            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1166                formatter.write_str("struct stream_plan.AsOfJoinNode")
1167            }
1168
1169            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinNode, V::Error>
1170                where
1171                    V: serde::de::MapAccess<'de>,
1172            {
1173                let mut join_type__ = None;
1174                let mut left_key__ = None;
1175                let mut right_key__ = None;
1176                let mut left_table__ = None;
1177                let mut right_table__ = None;
1178                let mut output_indices__ = None;
1179                let mut left_deduped_input_pk_indices__ = None;
1180                let mut right_deduped_input_pk_indices__ = None;
1181                let mut null_safe__ = None;
1182                let mut asof_desc__ = None;
1183                let mut join_encoding_type__ = None;
1184                while let Some(k) = map_.next_key()? {
1185                    match k {
1186                        GeneratedField::JoinType => {
1187                            if join_type__.is_some() {
1188                                return Err(serde::de::Error::duplicate_field("joinType"));
1189                            }
1190                            join_type__ = Some(map_.next_value::<super::plan_common::AsOfJoinType>()? as i32);
1191                        }
1192                        GeneratedField::LeftKey => {
1193                            if left_key__.is_some() {
1194                                return Err(serde::de::Error::duplicate_field("leftKey"));
1195                            }
1196                            left_key__ = 
1197                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1198                                    .into_iter().map(|x| x.0).collect())
1199                            ;
1200                        }
1201                        GeneratedField::RightKey => {
1202                            if right_key__.is_some() {
1203                                return Err(serde::de::Error::duplicate_field("rightKey"));
1204                            }
1205                            right_key__ = 
1206                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1207                                    .into_iter().map(|x| x.0).collect())
1208                            ;
1209                        }
1210                        GeneratedField::LeftTable => {
1211                            if left_table__.is_some() {
1212                                return Err(serde::de::Error::duplicate_field("leftTable"));
1213                            }
1214                            left_table__ = map_.next_value()?;
1215                        }
1216                        GeneratedField::RightTable => {
1217                            if right_table__.is_some() {
1218                                return Err(serde::de::Error::duplicate_field("rightTable"));
1219                            }
1220                            right_table__ = map_.next_value()?;
1221                        }
1222                        GeneratedField::OutputIndices => {
1223                            if output_indices__.is_some() {
1224                                return Err(serde::de::Error::duplicate_field("outputIndices"));
1225                            }
1226                            output_indices__ = 
1227                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1228                                    .into_iter().map(|x| x.0).collect())
1229                            ;
1230                        }
1231                        GeneratedField::LeftDedupedInputPkIndices => {
1232                            if left_deduped_input_pk_indices__.is_some() {
1233                                return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
1234                            }
1235                            left_deduped_input_pk_indices__ = 
1236                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1237                                    .into_iter().map(|x| x.0).collect())
1238                            ;
1239                        }
1240                        GeneratedField::RightDedupedInputPkIndices => {
1241                            if right_deduped_input_pk_indices__.is_some() {
1242                                return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
1243                            }
1244                            right_deduped_input_pk_indices__ = 
1245                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1246                                    .into_iter().map(|x| x.0).collect())
1247                            ;
1248                        }
1249                        GeneratedField::NullSafe => {
1250                            if null_safe__.is_some() {
1251                                return Err(serde::de::Error::duplicate_field("nullSafe"));
1252                            }
1253                            null_safe__ = Some(map_.next_value()?);
1254                        }
1255                        GeneratedField::AsofDesc => {
1256                            if asof_desc__.is_some() {
1257                                return Err(serde::de::Error::duplicate_field("asofDesc"));
1258                            }
1259                            asof_desc__ = map_.next_value()?;
1260                        }
1261                        GeneratedField::JoinEncodingType => {
1262                            if join_encoding_type__.is_some() {
1263                                return Err(serde::de::Error::duplicate_field("joinEncodingType"));
1264                            }
1265                            join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
1266                        }
1267                    }
1268                }
1269                Ok(AsOfJoinNode {
1270                    join_type: join_type__.unwrap_or_default(),
1271                    left_key: left_key__.unwrap_or_default(),
1272                    right_key: right_key__.unwrap_or_default(),
1273                    left_table: left_table__,
1274                    right_table: right_table__,
1275                    output_indices: output_indices__.unwrap_or_default(),
1276                    left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
1277                    right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
1278                    null_safe: null_safe__.unwrap_or_default(),
1279                    asof_desc: asof_desc__,
1280                    join_encoding_type: join_encoding_type__.unwrap_or_default(),
1281                })
1282            }
1283        }
1284        deserializer.deserialize_struct("stream_plan.AsOfJoinNode", FIELDS, GeneratedVisitor)
1285    }
1286}
1287impl serde::Serialize for BackfillOrder {
1288    #[allow(deprecated)]
1289    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1290    where
1291        S: serde::Serializer,
1292    {
1293        use serde::ser::SerializeStruct;
1294        let mut len = 0;
1295        if !self.order.is_empty() {
1296            len += 1;
1297        }
1298        let mut struct_ser = serializer.serialize_struct("stream_plan.BackfillOrder", len)?;
1299        if !self.order.is_empty() {
1300            struct_ser.serialize_field("order", &self.order)?;
1301        }
1302        struct_ser.end()
1303    }
1304}
1305impl<'de> serde::Deserialize<'de> for BackfillOrder {
1306    #[allow(deprecated)]
1307    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1308    where
1309        D: serde::Deserializer<'de>,
1310    {
1311        const FIELDS: &[&str] = &[
1312            "order",
1313        ];
1314
1315        #[allow(clippy::enum_variant_names)]
1316        enum GeneratedField {
1317            Order,
1318        }
1319        impl<'de> serde::Deserialize<'de> for GeneratedField {
1320            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1321            where
1322                D: serde::Deserializer<'de>,
1323            {
1324                struct GeneratedVisitor;
1325
1326                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1327                    type Value = GeneratedField;
1328
1329                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1330                        write!(formatter, "expected one of: {:?}", &FIELDS)
1331                    }
1332
1333                    #[allow(unused_variables)]
1334                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1335                    where
1336                        E: serde::de::Error,
1337                    {
1338                        match value {
1339                            "order" => Ok(GeneratedField::Order),
1340                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1341                        }
1342                    }
1343                }
1344                deserializer.deserialize_identifier(GeneratedVisitor)
1345            }
1346        }
1347        struct GeneratedVisitor;
1348        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1349            type Value = BackfillOrder;
1350
1351            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1352                formatter.write_str("struct stream_plan.BackfillOrder")
1353            }
1354
1355            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackfillOrder, V::Error>
1356                where
1357                    V: serde::de::MapAccess<'de>,
1358            {
1359                let mut order__ = None;
1360                while let Some(k) = map_.next_key()? {
1361                    match k {
1362                        GeneratedField::Order => {
1363                            if order__.is_some() {
1364                                return Err(serde::de::Error::duplicate_field("order"));
1365                            }
1366                            order__ = Some(
1367                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1368                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
1369                            );
1370                        }
1371                    }
1372                }
1373                Ok(BackfillOrder {
1374                    order: order__.unwrap_or_default(),
1375                })
1376            }
1377        }
1378        deserializer.deserialize_struct("stream_plan.BackfillOrder", FIELDS, GeneratedVisitor)
1379    }
1380}
1381impl serde::Serialize for Barrier {
1382    #[allow(deprecated)]
1383    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1384    where
1385        S: serde::Serializer,
1386    {
1387        use serde::ser::SerializeStruct;
1388        let mut len = 0;
1389        if self.epoch.is_some() {
1390            len += 1;
1391        }
1392        if self.mutation.is_some() {
1393            len += 1;
1394        }
1395        if !self.tracing_context.is_empty() {
1396            len += 1;
1397        }
1398        if self.kind != 0 {
1399            len += 1;
1400        }
1401        if !self.passed_actors.is_empty() {
1402            len += 1;
1403        }
1404        let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1405        if let Some(v) = self.epoch.as_ref() {
1406            struct_ser.serialize_field("epoch", v)?;
1407        }
1408        if let Some(v) = self.mutation.as_ref() {
1409            struct_ser.serialize_field("mutation", v)?;
1410        }
1411        if !self.tracing_context.is_empty() {
1412            struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1413        }
1414        if self.kind != 0 {
1415            let v = barrier::BarrierKind::try_from(self.kind)
1416                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1417            struct_ser.serialize_field("kind", &v)?;
1418        }
1419        if !self.passed_actors.is_empty() {
1420            struct_ser.serialize_field("passedActors", &self.passed_actors)?;
1421        }
1422        struct_ser.end()
1423    }
1424}
1425impl<'de> serde::Deserialize<'de> for Barrier {
1426    #[allow(deprecated)]
1427    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1428    where
1429        D: serde::Deserializer<'de>,
1430    {
1431        const FIELDS: &[&str] = &[
1432            "epoch",
1433            "mutation",
1434            "tracing_context",
1435            "tracingContext",
1436            "kind",
1437            "passed_actors",
1438            "passedActors",
1439        ];
1440
1441        #[allow(clippy::enum_variant_names)]
1442        enum GeneratedField {
1443            Epoch,
1444            Mutation,
1445            TracingContext,
1446            Kind,
1447            PassedActors,
1448        }
1449        impl<'de> serde::Deserialize<'de> for GeneratedField {
1450            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1451            where
1452                D: serde::Deserializer<'de>,
1453            {
1454                struct GeneratedVisitor;
1455
1456                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1457                    type Value = GeneratedField;
1458
1459                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1460                        write!(formatter, "expected one of: {:?}", &FIELDS)
1461                    }
1462
1463                    #[allow(unused_variables)]
1464                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1465                    where
1466                        E: serde::de::Error,
1467                    {
1468                        match value {
1469                            "epoch" => Ok(GeneratedField::Epoch),
1470                            "mutation" => Ok(GeneratedField::Mutation),
1471                            "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1472                            "kind" => Ok(GeneratedField::Kind),
1473                            "passedActors" | "passed_actors" => Ok(GeneratedField::PassedActors),
1474                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1475                        }
1476                    }
1477                }
1478                deserializer.deserialize_identifier(GeneratedVisitor)
1479            }
1480        }
1481        struct GeneratedVisitor;
1482        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1483            type Value = Barrier;
1484
1485            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1486                formatter.write_str("struct stream_plan.Barrier")
1487            }
1488
1489            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1490                where
1491                    V: serde::de::MapAccess<'de>,
1492            {
1493                let mut epoch__ = None;
1494                let mut mutation__ = None;
1495                let mut tracing_context__ = None;
1496                let mut kind__ = None;
1497                let mut passed_actors__ = None;
1498                while let Some(k) = map_.next_key()? {
1499                    match k {
1500                        GeneratedField::Epoch => {
1501                            if epoch__.is_some() {
1502                                return Err(serde::de::Error::duplicate_field("epoch"));
1503                            }
1504                            epoch__ = map_.next_value()?;
1505                        }
1506                        GeneratedField::Mutation => {
1507                            if mutation__.is_some() {
1508                                return Err(serde::de::Error::duplicate_field("mutation"));
1509                            }
1510                            mutation__ = map_.next_value()?;
1511                        }
1512                        GeneratedField::TracingContext => {
1513                            if tracing_context__.is_some() {
1514                                return Err(serde::de::Error::duplicate_field("tracingContext"));
1515                            }
1516                            tracing_context__ = Some(
1517                                map_.next_value::<std::collections::HashMap<_, _>>()?
1518                            );
1519                        }
1520                        GeneratedField::Kind => {
1521                            if kind__.is_some() {
1522                                return Err(serde::de::Error::duplicate_field("kind"));
1523                            }
1524                            kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1525                        }
1526                        GeneratedField::PassedActors => {
1527                            if passed_actors__.is_some() {
1528                                return Err(serde::de::Error::duplicate_field("passedActors"));
1529                            }
1530                            passed_actors__ = 
1531                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1532                                    .into_iter().map(|x| x.0).collect())
1533                            ;
1534                        }
1535                    }
1536                }
1537                Ok(Barrier {
1538                    epoch: epoch__,
1539                    mutation: mutation__,
1540                    tracing_context: tracing_context__.unwrap_or_default(),
1541                    kind: kind__.unwrap_or_default(),
1542                    passed_actors: passed_actors__.unwrap_or_default(),
1543                })
1544            }
1545        }
1546        deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1547    }
1548}
1549impl serde::Serialize for barrier::BarrierKind {
1550    #[allow(deprecated)]
1551    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1552    where
1553        S: serde::Serializer,
1554    {
1555        let variant = match self {
1556            Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1557            Self::Initial => "BARRIER_KIND_INITIAL",
1558            Self::Barrier => "BARRIER_KIND_BARRIER",
1559            Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1560        };
1561        serializer.serialize_str(variant)
1562    }
1563}
1564impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1565    #[allow(deprecated)]
1566    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1567    where
1568        D: serde::Deserializer<'de>,
1569    {
1570        const FIELDS: &[&str] = &[
1571            "BARRIER_KIND_UNSPECIFIED",
1572            "BARRIER_KIND_INITIAL",
1573            "BARRIER_KIND_BARRIER",
1574            "BARRIER_KIND_CHECKPOINT",
1575        ];
1576
1577        struct GeneratedVisitor;
1578
1579        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1580            type Value = barrier::BarrierKind;
1581
1582            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1583                write!(formatter, "expected one of: {:?}", &FIELDS)
1584            }
1585
1586            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1587            where
1588                E: serde::de::Error,
1589            {
1590                i32::try_from(v)
1591                    .ok()
1592                    .and_then(|x| x.try_into().ok())
1593                    .ok_or_else(|| {
1594                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1595                    })
1596            }
1597
1598            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1599            where
1600                E: serde::de::Error,
1601            {
1602                i32::try_from(v)
1603                    .ok()
1604                    .and_then(|x| x.try_into().ok())
1605                    .ok_or_else(|| {
1606                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1607                    })
1608            }
1609
1610            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1611            where
1612                E: serde::de::Error,
1613            {
1614                match value {
1615                    "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1616                    "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1617                    "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1618                    "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1619                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1620                }
1621            }
1622        }
1623        deserializer.deserialize_any(GeneratedVisitor)
1624    }
1625}
1626impl serde::Serialize for BarrierMutation {
1627    #[allow(deprecated)]
1628    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1629    where
1630        S: serde::Serializer,
1631    {
1632        use serde::ser::SerializeStruct;
1633        let mut len = 0;
1634        if self.mutation.is_some() {
1635            len += 1;
1636        }
1637        let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1638        if let Some(v) = self.mutation.as_ref() {
1639            match v {
1640                barrier_mutation::Mutation::Add(v) => {
1641                    struct_ser.serialize_field("add", v)?;
1642                }
1643                barrier_mutation::Mutation::Stop(v) => {
1644                    struct_ser.serialize_field("stop", v)?;
1645                }
1646                barrier_mutation::Mutation::Update(v) => {
1647                    struct_ser.serialize_field("update", v)?;
1648                }
1649                barrier_mutation::Mutation::Splits(v) => {
1650                    struct_ser.serialize_field("splits", v)?;
1651                }
1652                barrier_mutation::Mutation::Pause(v) => {
1653                    struct_ser.serialize_field("pause", v)?;
1654                }
1655                barrier_mutation::Mutation::Resume(v) => {
1656                    struct_ser.serialize_field("resume", v)?;
1657                }
1658                barrier_mutation::Mutation::Throttle(v) => {
1659                    struct_ser.serialize_field("throttle", v)?;
1660                }
1661                barrier_mutation::Mutation::DropSubscriptions(v) => {
1662                    struct_ser.serialize_field("dropSubscriptions", v)?;
1663                }
1664                barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1665                    struct_ser.serialize_field("connectorPropsChange", v)?;
1666                }
1667                barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1668                    struct_ser.serialize_field("startFragmentBackfill", v)?;
1669                }
1670                barrier_mutation::Mutation::Combined(v) => {
1671                    struct_ser.serialize_field("combined", v)?;
1672                }
1673            }
1674        }
1675        struct_ser.end()
1676    }
1677}
1678impl<'de> serde::Deserialize<'de> for BarrierMutation {
1679    #[allow(deprecated)]
1680    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1681    where
1682        D: serde::Deserializer<'de>,
1683    {
1684        const FIELDS: &[&str] = &[
1685            "add",
1686            "stop",
1687            "update",
1688            "splits",
1689            "pause",
1690            "resume",
1691            "throttle",
1692            "drop_subscriptions",
1693            "dropSubscriptions",
1694            "connector_props_change",
1695            "connectorPropsChange",
1696            "start_fragment_backfill",
1697            "startFragmentBackfill",
1698            "combined",
1699        ];
1700
1701        #[allow(clippy::enum_variant_names)]
1702        enum GeneratedField {
1703            Add,
1704            Stop,
1705            Update,
1706            Splits,
1707            Pause,
1708            Resume,
1709            Throttle,
1710            DropSubscriptions,
1711            ConnectorPropsChange,
1712            StartFragmentBackfill,
1713            Combined,
1714        }
1715        impl<'de> serde::Deserialize<'de> for GeneratedField {
1716            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1717            where
1718                D: serde::Deserializer<'de>,
1719            {
1720                struct GeneratedVisitor;
1721
1722                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1723                    type Value = GeneratedField;
1724
1725                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1726                        write!(formatter, "expected one of: {:?}", &FIELDS)
1727                    }
1728
1729                    #[allow(unused_variables)]
1730                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1731                    where
1732                        E: serde::de::Error,
1733                    {
1734                        match value {
1735                            "add" => Ok(GeneratedField::Add),
1736                            "stop" => Ok(GeneratedField::Stop),
1737                            "update" => Ok(GeneratedField::Update),
1738                            "splits" => Ok(GeneratedField::Splits),
1739                            "pause" => Ok(GeneratedField::Pause),
1740                            "resume" => Ok(GeneratedField::Resume),
1741                            "throttle" => Ok(GeneratedField::Throttle),
1742                            "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1743                            "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1744                            "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1745                            "combined" => Ok(GeneratedField::Combined),
1746                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1747                        }
1748                    }
1749                }
1750                deserializer.deserialize_identifier(GeneratedVisitor)
1751            }
1752        }
1753        struct GeneratedVisitor;
1754        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1755            type Value = BarrierMutation;
1756
1757            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1758                formatter.write_str("struct stream_plan.BarrierMutation")
1759            }
1760
1761            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1762                where
1763                    V: serde::de::MapAccess<'de>,
1764            {
1765                let mut mutation__ = None;
1766                while let Some(k) = map_.next_key()? {
1767                    match k {
1768                        GeneratedField::Add => {
1769                            if mutation__.is_some() {
1770                                return Err(serde::de::Error::duplicate_field("add"));
1771                            }
1772                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1773;
1774                        }
1775                        GeneratedField::Stop => {
1776                            if mutation__.is_some() {
1777                                return Err(serde::de::Error::duplicate_field("stop"));
1778                            }
1779                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1780;
1781                        }
1782                        GeneratedField::Update => {
1783                            if mutation__.is_some() {
1784                                return Err(serde::de::Error::duplicate_field("update"));
1785                            }
1786                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
1787;
1788                        }
1789                        GeneratedField::Splits => {
1790                            if mutation__.is_some() {
1791                                return Err(serde::de::Error::duplicate_field("splits"));
1792                            }
1793                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
1794;
1795                        }
1796                        GeneratedField::Pause => {
1797                            if mutation__.is_some() {
1798                                return Err(serde::de::Error::duplicate_field("pause"));
1799                            }
1800                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
1801;
1802                        }
1803                        GeneratedField::Resume => {
1804                            if mutation__.is_some() {
1805                                return Err(serde::de::Error::duplicate_field("resume"));
1806                            }
1807                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
1808;
1809                        }
1810                        GeneratedField::Throttle => {
1811                            if mutation__.is_some() {
1812                                return Err(serde::de::Error::duplicate_field("throttle"));
1813                            }
1814                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
1815;
1816                        }
1817                        GeneratedField::DropSubscriptions => {
1818                            if mutation__.is_some() {
1819                                return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
1820                            }
1821                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
1822;
1823                        }
1824                        GeneratedField::ConnectorPropsChange => {
1825                            if mutation__.is_some() {
1826                                return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
1827                            }
1828                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
1829;
1830                        }
1831                        GeneratedField::StartFragmentBackfill => {
1832                            if mutation__.is_some() {
1833                                return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
1834                            }
1835                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
1836;
1837                        }
1838                        GeneratedField::Combined => {
1839                            if mutation__.is_some() {
1840                                return Err(serde::de::Error::duplicate_field("combined"));
1841                            }
1842                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Combined)
1843;
1844                        }
1845                    }
1846                }
1847                Ok(BarrierMutation {
1848                    mutation: mutation__,
1849                })
1850            }
1851        }
1852        deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
1853    }
1854}
1855impl serde::Serialize for BarrierRecvNode {
1856    #[allow(deprecated)]
1857    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1858    where
1859        S: serde::Serializer,
1860    {
1861        use serde::ser::SerializeStruct;
1862        let len = 0;
1863        let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
1864        struct_ser.end()
1865    }
1866}
1867impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
1868    #[allow(deprecated)]
1869    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1870    where
1871        D: serde::Deserializer<'de>,
1872    {
1873        const FIELDS: &[&str] = &[
1874        ];
1875
1876        #[allow(clippy::enum_variant_names)]
1877        enum GeneratedField {
1878        }
1879        impl<'de> serde::Deserialize<'de> for GeneratedField {
1880            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1881            where
1882                D: serde::Deserializer<'de>,
1883            {
1884                struct GeneratedVisitor;
1885
1886                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1887                    type Value = GeneratedField;
1888
1889                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1890                        write!(formatter, "expected one of: {:?}", &FIELDS)
1891                    }
1892
1893                    #[allow(unused_variables)]
1894                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1895                    where
1896                        E: serde::de::Error,
1897                    {
1898                            Err(serde::de::Error::unknown_field(value, FIELDS))
1899                    }
1900                }
1901                deserializer.deserialize_identifier(GeneratedVisitor)
1902            }
1903        }
1904        struct GeneratedVisitor;
1905        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1906            type Value = BarrierRecvNode;
1907
1908            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1909                formatter.write_str("struct stream_plan.BarrierRecvNode")
1910            }
1911
1912            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
1913                where
1914                    V: serde::de::MapAccess<'de>,
1915            {
1916                while map_.next_key::<GeneratedField>()?.is_some() {
1917                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1918                }
1919                Ok(BarrierRecvNode {
1920                })
1921            }
1922        }
1923        deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
1924    }
1925}
1926impl serde::Serialize for BatchPlanNode {
1927    #[allow(deprecated)]
1928    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1929    where
1930        S: serde::Serializer,
1931    {
1932        use serde::ser::SerializeStruct;
1933        let mut len = 0;
1934        if self.table_desc.is_some() {
1935            len += 1;
1936        }
1937        if !self.column_ids.is_empty() {
1938            len += 1;
1939        }
1940        let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
1941        if let Some(v) = self.table_desc.as_ref() {
1942            struct_ser.serialize_field("tableDesc", v)?;
1943        }
1944        if !self.column_ids.is_empty() {
1945            struct_ser.serialize_field("columnIds", &self.column_ids)?;
1946        }
1947        struct_ser.end()
1948    }
1949}
1950impl<'de> serde::Deserialize<'de> for BatchPlanNode {
1951    #[allow(deprecated)]
1952    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1953    where
1954        D: serde::Deserializer<'de>,
1955    {
1956        const FIELDS: &[&str] = &[
1957            "table_desc",
1958            "tableDesc",
1959            "column_ids",
1960            "columnIds",
1961        ];
1962
1963        #[allow(clippy::enum_variant_names)]
1964        enum GeneratedField {
1965            TableDesc,
1966            ColumnIds,
1967        }
1968        impl<'de> serde::Deserialize<'de> for GeneratedField {
1969            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1970            where
1971                D: serde::Deserializer<'de>,
1972            {
1973                struct GeneratedVisitor;
1974
1975                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1976                    type Value = GeneratedField;
1977
1978                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1979                        write!(formatter, "expected one of: {:?}", &FIELDS)
1980                    }
1981
1982                    #[allow(unused_variables)]
1983                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1984                    where
1985                        E: serde::de::Error,
1986                    {
1987                        match value {
1988                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
1989                            "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
1990                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1991                        }
1992                    }
1993                }
1994                deserializer.deserialize_identifier(GeneratedVisitor)
1995            }
1996        }
1997        struct GeneratedVisitor;
1998        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1999            type Value = BatchPlanNode;
2000
2001            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2002                formatter.write_str("struct stream_plan.BatchPlanNode")
2003            }
2004
2005            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2006                where
2007                    V: serde::de::MapAccess<'de>,
2008            {
2009                let mut table_desc__ = None;
2010                let mut column_ids__ = None;
2011                while let Some(k) = map_.next_key()? {
2012                    match k {
2013                        GeneratedField::TableDesc => {
2014                            if table_desc__.is_some() {
2015                                return Err(serde::de::Error::duplicate_field("tableDesc"));
2016                            }
2017                            table_desc__ = map_.next_value()?;
2018                        }
2019                        GeneratedField::ColumnIds => {
2020                            if column_ids__.is_some() {
2021                                return Err(serde::de::Error::duplicate_field("columnIds"));
2022                            }
2023                            column_ids__ = 
2024                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2025                                    .into_iter().map(|x| x.0).collect())
2026                            ;
2027                        }
2028                    }
2029                }
2030                Ok(BatchPlanNode {
2031                    table_desc: table_desc__,
2032                    column_ids: column_ids__.unwrap_or_default(),
2033                })
2034            }
2035        }
2036        deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2037    }
2038}
2039impl serde::Serialize for CdcFilterNode {
2040    #[allow(deprecated)]
2041    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2042    where
2043        S: serde::Serializer,
2044    {
2045        use serde::ser::SerializeStruct;
2046        let mut len = 0;
2047        if self.search_condition.is_some() {
2048            len += 1;
2049        }
2050        if self.upstream_source_id != 0 {
2051            len += 1;
2052        }
2053        let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2054        if let Some(v) = self.search_condition.as_ref() {
2055            struct_ser.serialize_field("searchCondition", v)?;
2056        }
2057        if self.upstream_source_id != 0 {
2058            struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2059        }
2060        struct_ser.end()
2061    }
2062}
2063impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2064    #[allow(deprecated)]
2065    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2066    where
2067        D: serde::Deserializer<'de>,
2068    {
2069        const FIELDS: &[&str] = &[
2070            "search_condition",
2071            "searchCondition",
2072            "upstream_source_id",
2073            "upstreamSourceId",
2074        ];
2075
2076        #[allow(clippy::enum_variant_names)]
2077        enum GeneratedField {
2078            SearchCondition,
2079            UpstreamSourceId,
2080        }
2081        impl<'de> serde::Deserialize<'de> for GeneratedField {
2082            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2083            where
2084                D: serde::Deserializer<'de>,
2085            {
2086                struct GeneratedVisitor;
2087
2088                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2089                    type Value = GeneratedField;
2090
2091                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2092                        write!(formatter, "expected one of: {:?}", &FIELDS)
2093                    }
2094
2095                    #[allow(unused_variables)]
2096                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2097                    where
2098                        E: serde::de::Error,
2099                    {
2100                        match value {
2101                            "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2102                            "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2103                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2104                        }
2105                    }
2106                }
2107                deserializer.deserialize_identifier(GeneratedVisitor)
2108            }
2109        }
2110        struct GeneratedVisitor;
2111        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2112            type Value = CdcFilterNode;
2113
2114            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2115                formatter.write_str("struct stream_plan.CdcFilterNode")
2116            }
2117
2118            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2119                where
2120                    V: serde::de::MapAccess<'de>,
2121            {
2122                let mut search_condition__ = None;
2123                let mut upstream_source_id__ = None;
2124                while let Some(k) = map_.next_key()? {
2125                    match k {
2126                        GeneratedField::SearchCondition => {
2127                            if search_condition__.is_some() {
2128                                return Err(serde::de::Error::duplicate_field("searchCondition"));
2129                            }
2130                            search_condition__ = map_.next_value()?;
2131                        }
2132                        GeneratedField::UpstreamSourceId => {
2133                            if upstream_source_id__.is_some() {
2134                                return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2135                            }
2136                            upstream_source_id__ = 
2137                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2138                            ;
2139                        }
2140                    }
2141                }
2142                Ok(CdcFilterNode {
2143                    search_condition: search_condition__,
2144                    upstream_source_id: upstream_source_id__.unwrap_or_default(),
2145                })
2146            }
2147        }
2148        deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2149    }
2150}
2151impl serde::Serialize for ChangeLogNode {
2152    #[allow(deprecated)]
2153    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2154    where
2155        S: serde::Serializer,
2156    {
2157        use serde::ser::SerializeStruct;
2158        let mut len = 0;
2159        if self.need_op {
2160            len += 1;
2161        }
2162        let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2163        if self.need_op {
2164            struct_ser.serialize_field("needOp", &self.need_op)?;
2165        }
2166        struct_ser.end()
2167    }
2168}
2169impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2170    #[allow(deprecated)]
2171    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2172    where
2173        D: serde::Deserializer<'de>,
2174    {
2175        const FIELDS: &[&str] = &[
2176            "need_op",
2177            "needOp",
2178        ];
2179
2180        #[allow(clippy::enum_variant_names)]
2181        enum GeneratedField {
2182            NeedOp,
2183        }
2184        impl<'de> serde::Deserialize<'de> for GeneratedField {
2185            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2186            where
2187                D: serde::Deserializer<'de>,
2188            {
2189                struct GeneratedVisitor;
2190
2191                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2192                    type Value = GeneratedField;
2193
2194                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2195                        write!(formatter, "expected one of: {:?}", &FIELDS)
2196                    }
2197
2198                    #[allow(unused_variables)]
2199                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2200                    where
2201                        E: serde::de::Error,
2202                    {
2203                        match value {
2204                            "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2205                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2206                        }
2207                    }
2208                }
2209                deserializer.deserialize_identifier(GeneratedVisitor)
2210            }
2211        }
2212        struct GeneratedVisitor;
2213        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2214            type Value = ChangeLogNode;
2215
2216            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2217                formatter.write_str("struct stream_plan.ChangeLogNode")
2218            }
2219
2220            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2221                where
2222                    V: serde::de::MapAccess<'de>,
2223            {
2224                let mut need_op__ = None;
2225                while let Some(k) = map_.next_key()? {
2226                    match k {
2227                        GeneratedField::NeedOp => {
2228                            if need_op__.is_some() {
2229                                return Err(serde::de::Error::duplicate_field("needOp"));
2230                            }
2231                            need_op__ = Some(map_.next_value()?);
2232                        }
2233                    }
2234                }
2235                Ok(ChangeLogNode {
2236                    need_op: need_op__.unwrap_or_default(),
2237                })
2238            }
2239        }
2240        deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2241    }
2242}
2243impl serde::Serialize for CombinedMutation {
2244    #[allow(deprecated)]
2245    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2246    where
2247        S: serde::Serializer,
2248    {
2249        use serde::ser::SerializeStruct;
2250        let mut len = 0;
2251        if !self.mutations.is_empty() {
2252            len += 1;
2253        }
2254        let mut struct_ser = serializer.serialize_struct("stream_plan.CombinedMutation", len)?;
2255        if !self.mutations.is_empty() {
2256            struct_ser.serialize_field("mutations", &self.mutations)?;
2257        }
2258        struct_ser.end()
2259    }
2260}
2261impl<'de> serde::Deserialize<'de> for CombinedMutation {
2262    #[allow(deprecated)]
2263    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2264    where
2265        D: serde::Deserializer<'de>,
2266    {
2267        const FIELDS: &[&str] = &[
2268            "mutations",
2269        ];
2270
2271        #[allow(clippy::enum_variant_names)]
2272        enum GeneratedField {
2273            Mutations,
2274        }
2275        impl<'de> serde::Deserialize<'de> for GeneratedField {
2276            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2277            where
2278                D: serde::Deserializer<'de>,
2279            {
2280                struct GeneratedVisitor;
2281
2282                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2283                    type Value = GeneratedField;
2284
2285                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2286                        write!(formatter, "expected one of: {:?}", &FIELDS)
2287                    }
2288
2289                    #[allow(unused_variables)]
2290                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2291                    where
2292                        E: serde::de::Error,
2293                    {
2294                        match value {
2295                            "mutations" => Ok(GeneratedField::Mutations),
2296                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2297                        }
2298                    }
2299                }
2300                deserializer.deserialize_identifier(GeneratedVisitor)
2301            }
2302        }
2303        struct GeneratedVisitor;
2304        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2305            type Value = CombinedMutation;
2306
2307            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2308                formatter.write_str("struct stream_plan.CombinedMutation")
2309            }
2310
2311            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CombinedMutation, V::Error>
2312                where
2313                    V: serde::de::MapAccess<'de>,
2314            {
2315                let mut mutations__ = None;
2316                while let Some(k) = map_.next_key()? {
2317                    match k {
2318                        GeneratedField::Mutations => {
2319                            if mutations__.is_some() {
2320                                return Err(serde::de::Error::duplicate_field("mutations"));
2321                            }
2322                            mutations__ = Some(map_.next_value()?);
2323                        }
2324                    }
2325                }
2326                Ok(CombinedMutation {
2327                    mutations: mutations__.unwrap_or_default(),
2328                })
2329            }
2330        }
2331        deserializer.deserialize_struct("stream_plan.CombinedMutation", FIELDS, GeneratedVisitor)
2332    }
2333}
2334impl serde::Serialize for ConnectorPropsChangeMutation {
2335    #[allow(deprecated)]
2336    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2337    where
2338        S: serde::Serializer,
2339    {
2340        use serde::ser::SerializeStruct;
2341        let mut len = 0;
2342        if !self.connector_props_infos.is_empty() {
2343            len += 1;
2344        }
2345        let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2346        if !self.connector_props_infos.is_empty() {
2347            struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2348        }
2349        struct_ser.end()
2350    }
2351}
2352impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2353    #[allow(deprecated)]
2354    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2355    where
2356        D: serde::Deserializer<'de>,
2357    {
2358        const FIELDS: &[&str] = &[
2359            "connector_props_infos",
2360            "connectorPropsInfos",
2361        ];
2362
2363        #[allow(clippy::enum_variant_names)]
2364        enum GeneratedField {
2365            ConnectorPropsInfos,
2366        }
2367        impl<'de> serde::Deserialize<'de> for GeneratedField {
2368            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2369            where
2370                D: serde::Deserializer<'de>,
2371            {
2372                struct GeneratedVisitor;
2373
2374                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2375                    type Value = GeneratedField;
2376
2377                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2378                        write!(formatter, "expected one of: {:?}", &FIELDS)
2379                    }
2380
2381                    #[allow(unused_variables)]
2382                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2383                    where
2384                        E: serde::de::Error,
2385                    {
2386                        match value {
2387                            "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2388                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2389                        }
2390                    }
2391                }
2392                deserializer.deserialize_identifier(GeneratedVisitor)
2393            }
2394        }
2395        struct GeneratedVisitor;
2396        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2397            type Value = ConnectorPropsChangeMutation;
2398
2399            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2400                formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2401            }
2402
2403            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2404                where
2405                    V: serde::de::MapAccess<'de>,
2406            {
2407                let mut connector_props_infos__ = None;
2408                while let Some(k) = map_.next_key()? {
2409                    match k {
2410                        GeneratedField::ConnectorPropsInfos => {
2411                            if connector_props_infos__.is_some() {
2412                                return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2413                            }
2414                            connector_props_infos__ = Some(
2415                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2416                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
2417                            );
2418                        }
2419                    }
2420                }
2421                Ok(ConnectorPropsChangeMutation {
2422                    connector_props_infos: connector_props_infos__.unwrap_or_default(),
2423                })
2424            }
2425        }
2426        deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2427    }
2428}
2429impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2430    #[allow(deprecated)]
2431    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2432    where
2433        S: serde::Serializer,
2434    {
2435        use serde::ser::SerializeStruct;
2436        let mut len = 0;
2437        if !self.connector_props_info.is_empty() {
2438            len += 1;
2439        }
2440        let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2441        if !self.connector_props_info.is_empty() {
2442            struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2443        }
2444        struct_ser.end()
2445    }
2446}
2447impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2448    #[allow(deprecated)]
2449    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2450    where
2451        D: serde::Deserializer<'de>,
2452    {
2453        const FIELDS: &[&str] = &[
2454            "connector_props_info",
2455            "connectorPropsInfo",
2456        ];
2457
2458        #[allow(clippy::enum_variant_names)]
2459        enum GeneratedField {
2460            ConnectorPropsInfo,
2461        }
2462        impl<'de> serde::Deserialize<'de> for GeneratedField {
2463            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2464            where
2465                D: serde::Deserializer<'de>,
2466            {
2467                struct GeneratedVisitor;
2468
2469                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2470                    type Value = GeneratedField;
2471
2472                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2473                        write!(formatter, "expected one of: {:?}", &FIELDS)
2474                    }
2475
2476                    #[allow(unused_variables)]
2477                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2478                    where
2479                        E: serde::de::Error,
2480                    {
2481                        match value {
2482                            "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2483                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2484                        }
2485                    }
2486                }
2487                deserializer.deserialize_identifier(GeneratedVisitor)
2488            }
2489        }
2490        struct GeneratedVisitor;
2491        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2492            type Value = connector_props_change_mutation::ConnectorPropsInfo;
2493
2494            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2495                formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2496            }
2497
2498            fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2499                where
2500                    V: serde::de::MapAccess<'de>,
2501            {
2502                let mut connector_props_info__ = None;
2503                while let Some(k) = map_.next_key()? {
2504                    match k {
2505                        GeneratedField::ConnectorPropsInfo => {
2506                            if connector_props_info__.is_some() {
2507                                return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2508                            }
2509                            connector_props_info__ = Some(
2510                                map_.next_value::<std::collections::HashMap<_, _>>()?
2511                            );
2512                        }
2513                    }
2514                }
2515                Ok(connector_props_change_mutation::ConnectorPropsInfo {
2516                    connector_props_info: connector_props_info__.unwrap_or_default(),
2517                })
2518            }
2519        }
2520        deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2521    }
2522}
2523impl serde::Serialize for DedupNode {
2524    #[allow(deprecated)]
2525    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2526    where
2527        S: serde::Serializer,
2528    {
2529        use serde::ser::SerializeStruct;
2530        let mut len = 0;
2531        if self.state_table.is_some() {
2532            len += 1;
2533        }
2534        if !self.dedup_column_indices.is_empty() {
2535            len += 1;
2536        }
2537        let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
2538        if let Some(v) = self.state_table.as_ref() {
2539            struct_ser.serialize_field("stateTable", v)?;
2540        }
2541        if !self.dedup_column_indices.is_empty() {
2542            struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
2543        }
2544        struct_ser.end()
2545    }
2546}
2547impl<'de> serde::Deserialize<'de> for DedupNode {
2548    #[allow(deprecated)]
2549    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2550    where
2551        D: serde::Deserializer<'de>,
2552    {
2553        const FIELDS: &[&str] = &[
2554            "state_table",
2555            "stateTable",
2556            "dedup_column_indices",
2557            "dedupColumnIndices",
2558        ];
2559
2560        #[allow(clippy::enum_variant_names)]
2561        enum GeneratedField {
2562            StateTable,
2563            DedupColumnIndices,
2564        }
2565        impl<'de> serde::Deserialize<'de> for GeneratedField {
2566            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2567            where
2568                D: serde::Deserializer<'de>,
2569            {
2570                struct GeneratedVisitor;
2571
2572                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2573                    type Value = GeneratedField;
2574
2575                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2576                        write!(formatter, "expected one of: {:?}", &FIELDS)
2577                    }
2578
2579                    #[allow(unused_variables)]
2580                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2581                    where
2582                        E: serde::de::Error,
2583                    {
2584                        match value {
2585                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
2586                            "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
2587                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2588                        }
2589                    }
2590                }
2591                deserializer.deserialize_identifier(GeneratedVisitor)
2592            }
2593        }
2594        struct GeneratedVisitor;
2595        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2596            type Value = DedupNode;
2597
2598            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2599                formatter.write_str("struct stream_plan.DedupNode")
2600            }
2601
2602            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
2603                where
2604                    V: serde::de::MapAccess<'de>,
2605            {
2606                let mut state_table__ = None;
2607                let mut dedup_column_indices__ = None;
2608                while let Some(k) = map_.next_key()? {
2609                    match k {
2610                        GeneratedField::StateTable => {
2611                            if state_table__.is_some() {
2612                                return Err(serde::de::Error::duplicate_field("stateTable"));
2613                            }
2614                            state_table__ = map_.next_value()?;
2615                        }
2616                        GeneratedField::DedupColumnIndices => {
2617                            if dedup_column_indices__.is_some() {
2618                                return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
2619                            }
2620                            dedup_column_indices__ = 
2621                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2622                                    .into_iter().map(|x| x.0).collect())
2623                            ;
2624                        }
2625                    }
2626                }
2627                Ok(DedupNode {
2628                    state_table: state_table__,
2629                    dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
2630                })
2631            }
2632        }
2633        deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
2634    }
2635}
2636impl serde::Serialize for DeltaExpression {
2637    #[allow(deprecated)]
2638    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2639    where
2640        S: serde::Serializer,
2641    {
2642        use serde::ser::SerializeStruct;
2643        let mut len = 0;
2644        if self.delta_type != 0 {
2645            len += 1;
2646        }
2647        if self.delta.is_some() {
2648            len += 1;
2649        }
2650        let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
2651        if self.delta_type != 0 {
2652            let v = super::expr::expr_node::Type::try_from(self.delta_type)
2653                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
2654            struct_ser.serialize_field("deltaType", &v)?;
2655        }
2656        if let Some(v) = self.delta.as_ref() {
2657            struct_ser.serialize_field("delta", v)?;
2658        }
2659        struct_ser.end()
2660    }
2661}
2662impl<'de> serde::Deserialize<'de> for DeltaExpression {
2663    #[allow(deprecated)]
2664    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2665    where
2666        D: serde::Deserializer<'de>,
2667    {
2668        const FIELDS: &[&str] = &[
2669            "delta_type",
2670            "deltaType",
2671            "delta",
2672        ];
2673
2674        #[allow(clippy::enum_variant_names)]
2675        enum GeneratedField {
2676            DeltaType,
2677            Delta,
2678        }
2679        impl<'de> serde::Deserialize<'de> for GeneratedField {
2680            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2681            where
2682                D: serde::Deserializer<'de>,
2683            {
2684                struct GeneratedVisitor;
2685
2686                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2687                    type Value = GeneratedField;
2688
2689                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2690                        write!(formatter, "expected one of: {:?}", &FIELDS)
2691                    }
2692
2693                    #[allow(unused_variables)]
2694                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2695                    where
2696                        E: serde::de::Error,
2697                    {
2698                        match value {
2699                            "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
2700                            "delta" => Ok(GeneratedField::Delta),
2701                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2702                        }
2703                    }
2704                }
2705                deserializer.deserialize_identifier(GeneratedVisitor)
2706            }
2707        }
2708        struct GeneratedVisitor;
2709        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2710            type Value = DeltaExpression;
2711
2712            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2713                formatter.write_str("struct stream_plan.DeltaExpression")
2714            }
2715
2716            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
2717                where
2718                    V: serde::de::MapAccess<'de>,
2719            {
2720                let mut delta_type__ = None;
2721                let mut delta__ = None;
2722                while let Some(k) = map_.next_key()? {
2723                    match k {
2724                        GeneratedField::DeltaType => {
2725                            if delta_type__.is_some() {
2726                                return Err(serde::de::Error::duplicate_field("deltaType"));
2727                            }
2728                            delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
2729                        }
2730                        GeneratedField::Delta => {
2731                            if delta__.is_some() {
2732                                return Err(serde::de::Error::duplicate_field("delta"));
2733                            }
2734                            delta__ = map_.next_value()?;
2735                        }
2736                    }
2737                }
2738                Ok(DeltaExpression {
2739                    delta_type: delta_type__.unwrap_or_default(),
2740                    delta: delta__,
2741                })
2742            }
2743        }
2744        deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
2745    }
2746}
2747impl serde::Serialize for DeltaIndexJoinNode {
2748    #[allow(deprecated)]
2749    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2750    where
2751        S: serde::Serializer,
2752    {
2753        use serde::ser::SerializeStruct;
2754        let mut len = 0;
2755        if self.join_type != 0 {
2756            len += 1;
2757        }
2758        if !self.left_key.is_empty() {
2759            len += 1;
2760        }
2761        if !self.right_key.is_empty() {
2762            len += 1;
2763        }
2764        if self.condition.is_some() {
2765            len += 1;
2766        }
2767        if self.left_table_id != 0 {
2768            len += 1;
2769        }
2770        if self.right_table_id != 0 {
2771            len += 1;
2772        }
2773        if self.left_info.is_some() {
2774            len += 1;
2775        }
2776        if self.right_info.is_some() {
2777            len += 1;
2778        }
2779        if !self.output_indices.is_empty() {
2780            len += 1;
2781        }
2782        let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
2783        if self.join_type != 0 {
2784            let v = super::plan_common::JoinType::try_from(self.join_type)
2785                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
2786            struct_ser.serialize_field("joinType", &v)?;
2787        }
2788        if !self.left_key.is_empty() {
2789            struct_ser.serialize_field("leftKey", &self.left_key)?;
2790        }
2791        if !self.right_key.is_empty() {
2792            struct_ser.serialize_field("rightKey", &self.right_key)?;
2793        }
2794        if let Some(v) = self.condition.as_ref() {
2795            struct_ser.serialize_field("condition", v)?;
2796        }
2797        if self.left_table_id != 0 {
2798            struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
2799        }
2800        if self.right_table_id != 0 {
2801            struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
2802        }
2803        if let Some(v) = self.left_info.as_ref() {
2804            struct_ser.serialize_field("leftInfo", v)?;
2805        }
2806        if let Some(v) = self.right_info.as_ref() {
2807            struct_ser.serialize_field("rightInfo", v)?;
2808        }
2809        if !self.output_indices.is_empty() {
2810            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
2811        }
2812        struct_ser.end()
2813    }
2814}
2815impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
2816    #[allow(deprecated)]
2817    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2818    where
2819        D: serde::Deserializer<'de>,
2820    {
2821        const FIELDS: &[&str] = &[
2822            "join_type",
2823            "joinType",
2824            "left_key",
2825            "leftKey",
2826            "right_key",
2827            "rightKey",
2828            "condition",
2829            "left_table_id",
2830            "leftTableId",
2831            "right_table_id",
2832            "rightTableId",
2833            "left_info",
2834            "leftInfo",
2835            "right_info",
2836            "rightInfo",
2837            "output_indices",
2838            "outputIndices",
2839        ];
2840
2841        #[allow(clippy::enum_variant_names)]
2842        enum GeneratedField {
2843            JoinType,
2844            LeftKey,
2845            RightKey,
2846            Condition,
2847            LeftTableId,
2848            RightTableId,
2849            LeftInfo,
2850            RightInfo,
2851            OutputIndices,
2852        }
2853        impl<'de> serde::Deserialize<'de> for GeneratedField {
2854            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2855            where
2856                D: serde::Deserializer<'de>,
2857            {
2858                struct GeneratedVisitor;
2859
2860                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2861                    type Value = GeneratedField;
2862
2863                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2864                        write!(formatter, "expected one of: {:?}", &FIELDS)
2865                    }
2866
2867                    #[allow(unused_variables)]
2868                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2869                    where
2870                        E: serde::de::Error,
2871                    {
2872                        match value {
2873                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
2874                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
2875                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
2876                            "condition" => Ok(GeneratedField::Condition),
2877                            "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
2878                            "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
2879                            "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
2880                            "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
2881                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
2882                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2883                        }
2884                    }
2885                }
2886                deserializer.deserialize_identifier(GeneratedVisitor)
2887            }
2888        }
2889        struct GeneratedVisitor;
2890        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2891            type Value = DeltaIndexJoinNode;
2892
2893            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2894                formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
2895            }
2896
2897            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
2898                where
2899                    V: serde::de::MapAccess<'de>,
2900            {
2901                let mut join_type__ = None;
2902                let mut left_key__ = None;
2903                let mut right_key__ = None;
2904                let mut condition__ = None;
2905                let mut left_table_id__ = None;
2906                let mut right_table_id__ = None;
2907                let mut left_info__ = None;
2908                let mut right_info__ = None;
2909                let mut output_indices__ = None;
2910                while let Some(k) = map_.next_key()? {
2911                    match k {
2912                        GeneratedField::JoinType => {
2913                            if join_type__.is_some() {
2914                                return Err(serde::de::Error::duplicate_field("joinType"));
2915                            }
2916                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
2917                        }
2918                        GeneratedField::LeftKey => {
2919                            if left_key__.is_some() {
2920                                return Err(serde::de::Error::duplicate_field("leftKey"));
2921                            }
2922                            left_key__ = 
2923                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2924                                    .into_iter().map(|x| x.0).collect())
2925                            ;
2926                        }
2927                        GeneratedField::RightKey => {
2928                            if right_key__.is_some() {
2929                                return Err(serde::de::Error::duplicate_field("rightKey"));
2930                            }
2931                            right_key__ = 
2932                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2933                                    .into_iter().map(|x| x.0).collect())
2934                            ;
2935                        }
2936                        GeneratedField::Condition => {
2937                            if condition__.is_some() {
2938                                return Err(serde::de::Error::duplicate_field("condition"));
2939                            }
2940                            condition__ = map_.next_value()?;
2941                        }
2942                        GeneratedField::LeftTableId => {
2943                            if left_table_id__.is_some() {
2944                                return Err(serde::de::Error::duplicate_field("leftTableId"));
2945                            }
2946                            left_table_id__ = 
2947                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2948                            ;
2949                        }
2950                        GeneratedField::RightTableId => {
2951                            if right_table_id__.is_some() {
2952                                return Err(serde::de::Error::duplicate_field("rightTableId"));
2953                            }
2954                            right_table_id__ = 
2955                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2956                            ;
2957                        }
2958                        GeneratedField::LeftInfo => {
2959                            if left_info__.is_some() {
2960                                return Err(serde::de::Error::duplicate_field("leftInfo"));
2961                            }
2962                            left_info__ = map_.next_value()?;
2963                        }
2964                        GeneratedField::RightInfo => {
2965                            if right_info__.is_some() {
2966                                return Err(serde::de::Error::duplicate_field("rightInfo"));
2967                            }
2968                            right_info__ = map_.next_value()?;
2969                        }
2970                        GeneratedField::OutputIndices => {
2971                            if output_indices__.is_some() {
2972                                return Err(serde::de::Error::duplicate_field("outputIndices"));
2973                            }
2974                            output_indices__ = 
2975                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2976                                    .into_iter().map(|x| x.0).collect())
2977                            ;
2978                        }
2979                    }
2980                }
2981                Ok(DeltaIndexJoinNode {
2982                    join_type: join_type__.unwrap_or_default(),
2983                    left_key: left_key__.unwrap_or_default(),
2984                    right_key: right_key__.unwrap_or_default(),
2985                    condition: condition__,
2986                    left_table_id: left_table_id__.unwrap_or_default(),
2987                    right_table_id: right_table_id__.unwrap_or_default(),
2988                    left_info: left_info__,
2989                    right_info: right_info__,
2990                    output_indices: output_indices__.unwrap_or_default(),
2991                })
2992            }
2993        }
2994        deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
2995    }
2996}
2997impl serde::Serialize for DispatchOutputMapping {
2998    #[allow(deprecated)]
2999    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3000    where
3001        S: serde::Serializer,
3002    {
3003        use serde::ser::SerializeStruct;
3004        let mut len = 0;
3005        if !self.indices.is_empty() {
3006            len += 1;
3007        }
3008        if !self.types.is_empty() {
3009            len += 1;
3010        }
3011        let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3012        if !self.indices.is_empty() {
3013            struct_ser.serialize_field("indices", &self.indices)?;
3014        }
3015        if !self.types.is_empty() {
3016            struct_ser.serialize_field("types", &self.types)?;
3017        }
3018        struct_ser.end()
3019    }
3020}
3021impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3022    #[allow(deprecated)]
3023    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3024    where
3025        D: serde::Deserializer<'de>,
3026    {
3027        const FIELDS: &[&str] = &[
3028            "indices",
3029            "types",
3030        ];
3031
3032        #[allow(clippy::enum_variant_names)]
3033        enum GeneratedField {
3034            Indices,
3035            Types,
3036        }
3037        impl<'de> serde::Deserialize<'de> for GeneratedField {
3038            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3039            where
3040                D: serde::Deserializer<'de>,
3041            {
3042                struct GeneratedVisitor;
3043
3044                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3045                    type Value = GeneratedField;
3046
3047                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3048                        write!(formatter, "expected one of: {:?}", &FIELDS)
3049                    }
3050
3051                    #[allow(unused_variables)]
3052                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3053                    where
3054                        E: serde::de::Error,
3055                    {
3056                        match value {
3057                            "indices" => Ok(GeneratedField::Indices),
3058                            "types" => Ok(GeneratedField::Types),
3059                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3060                        }
3061                    }
3062                }
3063                deserializer.deserialize_identifier(GeneratedVisitor)
3064            }
3065        }
3066        struct GeneratedVisitor;
3067        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3068            type Value = DispatchOutputMapping;
3069
3070            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3071                formatter.write_str("struct stream_plan.DispatchOutputMapping")
3072            }
3073
3074            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3075                where
3076                    V: serde::de::MapAccess<'de>,
3077            {
3078                let mut indices__ = None;
3079                let mut types__ = None;
3080                while let Some(k) = map_.next_key()? {
3081                    match k {
3082                        GeneratedField::Indices => {
3083                            if indices__.is_some() {
3084                                return Err(serde::de::Error::duplicate_field("indices"));
3085                            }
3086                            indices__ = 
3087                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3088                                    .into_iter().map(|x| x.0).collect())
3089                            ;
3090                        }
3091                        GeneratedField::Types => {
3092                            if types__.is_some() {
3093                                return Err(serde::de::Error::duplicate_field("types"));
3094                            }
3095                            types__ = Some(map_.next_value()?);
3096                        }
3097                    }
3098                }
3099                Ok(DispatchOutputMapping {
3100                    indices: indices__.unwrap_or_default(),
3101                    types: types__.unwrap_or_default(),
3102                })
3103            }
3104        }
3105        deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3106    }
3107}
3108impl serde::Serialize for dispatch_output_mapping::TypePair {
3109    #[allow(deprecated)]
3110    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3111    where
3112        S: serde::Serializer,
3113    {
3114        use serde::ser::SerializeStruct;
3115        let mut len = 0;
3116        if self.upstream.is_some() {
3117            len += 1;
3118        }
3119        if self.downstream.is_some() {
3120            len += 1;
3121        }
3122        let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3123        if let Some(v) = self.upstream.as_ref() {
3124            struct_ser.serialize_field("upstream", v)?;
3125        }
3126        if let Some(v) = self.downstream.as_ref() {
3127            struct_ser.serialize_field("downstream", v)?;
3128        }
3129        struct_ser.end()
3130    }
3131}
3132impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3133    #[allow(deprecated)]
3134    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3135    where
3136        D: serde::Deserializer<'de>,
3137    {
3138        const FIELDS: &[&str] = &[
3139            "upstream",
3140            "downstream",
3141        ];
3142
3143        #[allow(clippy::enum_variant_names)]
3144        enum GeneratedField {
3145            Upstream,
3146            Downstream,
3147        }
3148        impl<'de> serde::Deserialize<'de> for GeneratedField {
3149            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3150            where
3151                D: serde::Deserializer<'de>,
3152            {
3153                struct GeneratedVisitor;
3154
3155                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3156                    type Value = GeneratedField;
3157
3158                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3159                        write!(formatter, "expected one of: {:?}", &FIELDS)
3160                    }
3161
3162                    #[allow(unused_variables)]
3163                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3164                    where
3165                        E: serde::de::Error,
3166                    {
3167                        match value {
3168                            "upstream" => Ok(GeneratedField::Upstream),
3169                            "downstream" => Ok(GeneratedField::Downstream),
3170                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3171                        }
3172                    }
3173                }
3174                deserializer.deserialize_identifier(GeneratedVisitor)
3175            }
3176        }
3177        struct GeneratedVisitor;
3178        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3179            type Value = dispatch_output_mapping::TypePair;
3180
3181            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3182                formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3183            }
3184
3185            fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3186                where
3187                    V: serde::de::MapAccess<'de>,
3188            {
3189                let mut upstream__ = None;
3190                let mut downstream__ = None;
3191                while let Some(k) = map_.next_key()? {
3192                    match k {
3193                        GeneratedField::Upstream => {
3194                            if upstream__.is_some() {
3195                                return Err(serde::de::Error::duplicate_field("upstream"));
3196                            }
3197                            upstream__ = map_.next_value()?;
3198                        }
3199                        GeneratedField::Downstream => {
3200                            if downstream__.is_some() {
3201                                return Err(serde::de::Error::duplicate_field("downstream"));
3202                            }
3203                            downstream__ = map_.next_value()?;
3204                        }
3205                    }
3206                }
3207                Ok(dispatch_output_mapping::TypePair {
3208                    upstream: upstream__,
3209                    downstream: downstream__,
3210                })
3211            }
3212        }
3213        deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3214    }
3215}
3216impl serde::Serialize for DispatchStrategy {
3217    #[allow(deprecated)]
3218    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3219    where
3220        S: serde::Serializer,
3221    {
3222        use serde::ser::SerializeStruct;
3223        let mut len = 0;
3224        if self.r#type != 0 {
3225            len += 1;
3226        }
3227        if !self.dist_key_indices.is_empty() {
3228            len += 1;
3229        }
3230        if self.output_mapping.is_some() {
3231            len += 1;
3232        }
3233        let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3234        if self.r#type != 0 {
3235            let v = DispatcherType::try_from(self.r#type)
3236                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3237            struct_ser.serialize_field("type", &v)?;
3238        }
3239        if !self.dist_key_indices.is_empty() {
3240            struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3241        }
3242        if let Some(v) = self.output_mapping.as_ref() {
3243            struct_ser.serialize_field("outputMapping", v)?;
3244        }
3245        struct_ser.end()
3246    }
3247}
3248impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3249    #[allow(deprecated)]
3250    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3251    where
3252        D: serde::Deserializer<'de>,
3253    {
3254        const FIELDS: &[&str] = &[
3255            "type",
3256            "dist_key_indices",
3257            "distKeyIndices",
3258            "output_mapping",
3259            "outputMapping",
3260        ];
3261
3262        #[allow(clippy::enum_variant_names)]
3263        enum GeneratedField {
3264            Type,
3265            DistKeyIndices,
3266            OutputMapping,
3267        }
3268        impl<'de> serde::Deserialize<'de> for GeneratedField {
3269            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3270            where
3271                D: serde::Deserializer<'de>,
3272            {
3273                struct GeneratedVisitor;
3274
3275                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3276                    type Value = GeneratedField;
3277
3278                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3279                        write!(formatter, "expected one of: {:?}", &FIELDS)
3280                    }
3281
3282                    #[allow(unused_variables)]
3283                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3284                    where
3285                        E: serde::de::Error,
3286                    {
3287                        match value {
3288                            "type" => Ok(GeneratedField::Type),
3289                            "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3290                            "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3291                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3292                        }
3293                    }
3294                }
3295                deserializer.deserialize_identifier(GeneratedVisitor)
3296            }
3297        }
3298        struct GeneratedVisitor;
3299        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3300            type Value = DispatchStrategy;
3301
3302            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3303                formatter.write_str("struct stream_plan.DispatchStrategy")
3304            }
3305
3306            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3307                where
3308                    V: serde::de::MapAccess<'de>,
3309            {
3310                let mut r#type__ = None;
3311                let mut dist_key_indices__ = None;
3312                let mut output_mapping__ = None;
3313                while let Some(k) = map_.next_key()? {
3314                    match k {
3315                        GeneratedField::Type => {
3316                            if r#type__.is_some() {
3317                                return Err(serde::de::Error::duplicate_field("type"));
3318                            }
3319                            r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3320                        }
3321                        GeneratedField::DistKeyIndices => {
3322                            if dist_key_indices__.is_some() {
3323                                return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3324                            }
3325                            dist_key_indices__ = 
3326                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3327                                    .into_iter().map(|x| x.0).collect())
3328                            ;
3329                        }
3330                        GeneratedField::OutputMapping => {
3331                            if output_mapping__.is_some() {
3332                                return Err(serde::de::Error::duplicate_field("outputMapping"));
3333                            }
3334                            output_mapping__ = map_.next_value()?;
3335                        }
3336                    }
3337                }
3338                Ok(DispatchStrategy {
3339                    r#type: r#type__.unwrap_or_default(),
3340                    dist_key_indices: dist_key_indices__.unwrap_or_default(),
3341                    output_mapping: output_mapping__,
3342                })
3343            }
3344        }
3345        deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3346    }
3347}
3348impl serde::Serialize for Dispatcher {
3349    #[allow(deprecated)]
3350    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3351    where
3352        S: serde::Serializer,
3353    {
3354        use serde::ser::SerializeStruct;
3355        let mut len = 0;
3356        if self.r#type != 0 {
3357            len += 1;
3358        }
3359        if !self.dist_key_indices.is_empty() {
3360            len += 1;
3361        }
3362        if self.output_mapping.is_some() {
3363            len += 1;
3364        }
3365        if self.hash_mapping.is_some() {
3366            len += 1;
3367        }
3368        if self.dispatcher_id != 0 {
3369            len += 1;
3370        }
3371        if !self.downstream_actor_id.is_empty() {
3372            len += 1;
3373        }
3374        let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3375        if self.r#type != 0 {
3376            let v = DispatcherType::try_from(self.r#type)
3377                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3378            struct_ser.serialize_field("type", &v)?;
3379        }
3380        if !self.dist_key_indices.is_empty() {
3381            struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3382        }
3383        if let Some(v) = self.output_mapping.as_ref() {
3384            struct_ser.serialize_field("outputMapping", v)?;
3385        }
3386        if let Some(v) = self.hash_mapping.as_ref() {
3387            struct_ser.serialize_field("hashMapping", v)?;
3388        }
3389        if self.dispatcher_id != 0 {
3390            #[allow(clippy::needless_borrow)]
3391            #[allow(clippy::needless_borrows_for_generic_args)]
3392            struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
3393        }
3394        if !self.downstream_actor_id.is_empty() {
3395            struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3396        }
3397        struct_ser.end()
3398    }
3399}
3400impl<'de> serde::Deserialize<'de> for Dispatcher {
3401    #[allow(deprecated)]
3402    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3403    where
3404        D: serde::Deserializer<'de>,
3405    {
3406        const FIELDS: &[&str] = &[
3407            "type",
3408            "dist_key_indices",
3409            "distKeyIndices",
3410            "output_mapping",
3411            "outputMapping",
3412            "hash_mapping",
3413            "hashMapping",
3414            "dispatcher_id",
3415            "dispatcherId",
3416            "downstream_actor_id",
3417            "downstreamActorId",
3418        ];
3419
3420        #[allow(clippy::enum_variant_names)]
3421        enum GeneratedField {
3422            Type,
3423            DistKeyIndices,
3424            OutputMapping,
3425            HashMapping,
3426            DispatcherId,
3427            DownstreamActorId,
3428        }
3429        impl<'de> serde::Deserialize<'de> for GeneratedField {
3430            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3431            where
3432                D: serde::Deserializer<'de>,
3433            {
3434                struct GeneratedVisitor;
3435
3436                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3437                    type Value = GeneratedField;
3438
3439                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3440                        write!(formatter, "expected one of: {:?}", &FIELDS)
3441                    }
3442
3443                    #[allow(unused_variables)]
3444                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3445                    where
3446                        E: serde::de::Error,
3447                    {
3448                        match value {
3449                            "type" => Ok(GeneratedField::Type),
3450                            "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3451                            "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3452                            "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3453                            "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3454                            "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3455                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3456                        }
3457                    }
3458                }
3459                deserializer.deserialize_identifier(GeneratedVisitor)
3460            }
3461        }
3462        struct GeneratedVisitor;
3463        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3464            type Value = Dispatcher;
3465
3466            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3467                formatter.write_str("struct stream_plan.Dispatcher")
3468            }
3469
3470            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3471                where
3472                    V: serde::de::MapAccess<'de>,
3473            {
3474                let mut r#type__ = None;
3475                let mut dist_key_indices__ = None;
3476                let mut output_mapping__ = None;
3477                let mut hash_mapping__ = None;
3478                let mut dispatcher_id__ = None;
3479                let mut downstream_actor_id__ = None;
3480                while let Some(k) = map_.next_key()? {
3481                    match k {
3482                        GeneratedField::Type => {
3483                            if r#type__.is_some() {
3484                                return Err(serde::de::Error::duplicate_field("type"));
3485                            }
3486                            r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3487                        }
3488                        GeneratedField::DistKeyIndices => {
3489                            if dist_key_indices__.is_some() {
3490                                return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3491                            }
3492                            dist_key_indices__ = 
3493                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3494                                    .into_iter().map(|x| x.0).collect())
3495                            ;
3496                        }
3497                        GeneratedField::OutputMapping => {
3498                            if output_mapping__.is_some() {
3499                                return Err(serde::de::Error::duplicate_field("outputMapping"));
3500                            }
3501                            output_mapping__ = map_.next_value()?;
3502                        }
3503                        GeneratedField::HashMapping => {
3504                            if hash_mapping__.is_some() {
3505                                return Err(serde::de::Error::duplicate_field("hashMapping"));
3506                            }
3507                            hash_mapping__ = map_.next_value()?;
3508                        }
3509                        GeneratedField::DispatcherId => {
3510                            if dispatcher_id__.is_some() {
3511                                return Err(serde::de::Error::duplicate_field("dispatcherId"));
3512                            }
3513                            dispatcher_id__ = 
3514                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3515                            ;
3516                        }
3517                        GeneratedField::DownstreamActorId => {
3518                            if downstream_actor_id__.is_some() {
3519                                return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3520                            }
3521                            downstream_actor_id__ = 
3522                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3523                                    .into_iter().map(|x| x.0).collect())
3524                            ;
3525                        }
3526                    }
3527                }
3528                Ok(Dispatcher {
3529                    r#type: r#type__.unwrap_or_default(),
3530                    dist_key_indices: dist_key_indices__.unwrap_or_default(),
3531                    output_mapping: output_mapping__,
3532                    hash_mapping: hash_mapping__,
3533                    dispatcher_id: dispatcher_id__.unwrap_or_default(),
3534                    downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3535                })
3536            }
3537        }
3538        deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3539    }
3540}
3541impl serde::Serialize for DispatcherType {
3542    #[allow(deprecated)]
3543    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3544    where
3545        S: serde::Serializer,
3546    {
3547        let variant = match self {
3548            Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3549            Self::Hash => "DISPATCHER_TYPE_HASH",
3550            Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3551            Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3552            Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3553        };
3554        serializer.serialize_str(variant)
3555    }
3556}
3557impl<'de> serde::Deserialize<'de> for DispatcherType {
3558    #[allow(deprecated)]
3559    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3560    where
3561        D: serde::Deserializer<'de>,
3562    {
3563        const FIELDS: &[&str] = &[
3564            "DISPATCHER_TYPE_UNSPECIFIED",
3565            "DISPATCHER_TYPE_HASH",
3566            "DISPATCHER_TYPE_BROADCAST",
3567            "DISPATCHER_TYPE_SIMPLE",
3568            "DISPATCHER_TYPE_NO_SHUFFLE",
3569        ];
3570
3571        struct GeneratedVisitor;
3572
3573        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3574            type Value = DispatcherType;
3575
3576            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3577                write!(formatter, "expected one of: {:?}", &FIELDS)
3578            }
3579
3580            fn visit_i64<E>(self, v: i64) -> 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::Signed(v), &self)
3589                    })
3590            }
3591
3592            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3593            where
3594                E: serde::de::Error,
3595            {
3596                i32::try_from(v)
3597                    .ok()
3598                    .and_then(|x| x.try_into().ok())
3599                    .ok_or_else(|| {
3600                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3601                    })
3602            }
3603
3604            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3605            where
3606                E: serde::de::Error,
3607            {
3608                match value {
3609                    "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3610                    "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3611                    "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3612                    "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3613                    "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3614                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3615                }
3616            }
3617        }
3618        deserializer.deserialize_any(GeneratedVisitor)
3619    }
3620}
3621impl serde::Serialize for Dispatchers {
3622    #[allow(deprecated)]
3623    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3624    where
3625        S: serde::Serializer,
3626    {
3627        use serde::ser::SerializeStruct;
3628        let mut len = 0;
3629        if !self.dispatchers.is_empty() {
3630            len += 1;
3631        }
3632        let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3633        if !self.dispatchers.is_empty() {
3634            struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3635        }
3636        struct_ser.end()
3637    }
3638}
3639impl<'de> serde::Deserialize<'de> for Dispatchers {
3640    #[allow(deprecated)]
3641    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3642    where
3643        D: serde::Deserializer<'de>,
3644    {
3645        const FIELDS: &[&str] = &[
3646            "dispatchers",
3647        ];
3648
3649        #[allow(clippy::enum_variant_names)]
3650        enum GeneratedField {
3651            Dispatchers,
3652        }
3653        impl<'de> serde::Deserialize<'de> for GeneratedField {
3654            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3655            where
3656                D: serde::Deserializer<'de>,
3657            {
3658                struct GeneratedVisitor;
3659
3660                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3661                    type Value = GeneratedField;
3662
3663                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3664                        write!(formatter, "expected one of: {:?}", &FIELDS)
3665                    }
3666
3667                    #[allow(unused_variables)]
3668                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3669                    where
3670                        E: serde::de::Error,
3671                    {
3672                        match value {
3673                            "dispatchers" => Ok(GeneratedField::Dispatchers),
3674                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3675                        }
3676                    }
3677                }
3678                deserializer.deserialize_identifier(GeneratedVisitor)
3679            }
3680        }
3681        struct GeneratedVisitor;
3682        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3683            type Value = Dispatchers;
3684
3685            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3686                formatter.write_str("struct stream_plan.Dispatchers")
3687            }
3688
3689            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3690                where
3691                    V: serde::de::MapAccess<'de>,
3692            {
3693                let mut dispatchers__ = None;
3694                while let Some(k) = map_.next_key()? {
3695                    match k {
3696                        GeneratedField::Dispatchers => {
3697                            if dispatchers__.is_some() {
3698                                return Err(serde::de::Error::duplicate_field("dispatchers"));
3699                            }
3700                            dispatchers__ = Some(map_.next_value()?);
3701                        }
3702                    }
3703                }
3704                Ok(Dispatchers {
3705                    dispatchers: dispatchers__.unwrap_or_default(),
3706                })
3707            }
3708        }
3709        deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
3710    }
3711}
3712impl serde::Serialize for DmlNode {
3713    #[allow(deprecated)]
3714    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3715    where
3716        S: serde::Serializer,
3717    {
3718        use serde::ser::SerializeStruct;
3719        let mut len = 0;
3720        if self.table_id != 0 {
3721            len += 1;
3722        }
3723        if self.table_version_id != 0 {
3724            len += 1;
3725        }
3726        if !self.column_descs.is_empty() {
3727            len += 1;
3728        }
3729        if self.rate_limit.is_some() {
3730            len += 1;
3731        }
3732        let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
3733        if self.table_id != 0 {
3734            struct_ser.serialize_field("tableId", &self.table_id)?;
3735        }
3736        if self.table_version_id != 0 {
3737            #[allow(clippy::needless_borrow)]
3738            #[allow(clippy::needless_borrows_for_generic_args)]
3739            struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3740        }
3741        if !self.column_descs.is_empty() {
3742            struct_ser.serialize_field("columnDescs", &self.column_descs)?;
3743        }
3744        if let Some(v) = self.rate_limit.as_ref() {
3745            struct_ser.serialize_field("rateLimit", v)?;
3746        }
3747        struct_ser.end()
3748    }
3749}
3750impl<'de> serde::Deserialize<'de> for DmlNode {
3751    #[allow(deprecated)]
3752    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3753    where
3754        D: serde::Deserializer<'de>,
3755    {
3756        const FIELDS: &[&str] = &[
3757            "table_id",
3758            "tableId",
3759            "table_version_id",
3760            "tableVersionId",
3761            "column_descs",
3762            "columnDescs",
3763            "rate_limit",
3764            "rateLimit",
3765        ];
3766
3767        #[allow(clippy::enum_variant_names)]
3768        enum GeneratedField {
3769            TableId,
3770            TableVersionId,
3771            ColumnDescs,
3772            RateLimit,
3773        }
3774        impl<'de> serde::Deserialize<'de> for GeneratedField {
3775            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3776            where
3777                D: serde::Deserializer<'de>,
3778            {
3779                struct GeneratedVisitor;
3780
3781                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3782                    type Value = GeneratedField;
3783
3784                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3785                        write!(formatter, "expected one of: {:?}", &FIELDS)
3786                    }
3787
3788                    #[allow(unused_variables)]
3789                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3790                    where
3791                        E: serde::de::Error,
3792                    {
3793                        match value {
3794                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
3795                            "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
3796                            "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
3797                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
3798                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3799                        }
3800                    }
3801                }
3802                deserializer.deserialize_identifier(GeneratedVisitor)
3803            }
3804        }
3805        struct GeneratedVisitor;
3806        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3807            type Value = DmlNode;
3808
3809            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3810                formatter.write_str("struct stream_plan.DmlNode")
3811            }
3812
3813            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
3814                where
3815                    V: serde::de::MapAccess<'de>,
3816            {
3817                let mut table_id__ = None;
3818                let mut table_version_id__ = None;
3819                let mut column_descs__ = None;
3820                let mut rate_limit__ = None;
3821                while let Some(k) = map_.next_key()? {
3822                    match k {
3823                        GeneratedField::TableId => {
3824                            if table_id__.is_some() {
3825                                return Err(serde::de::Error::duplicate_field("tableId"));
3826                            }
3827                            table_id__ = 
3828                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3829                            ;
3830                        }
3831                        GeneratedField::TableVersionId => {
3832                            if table_version_id__.is_some() {
3833                                return Err(serde::de::Error::duplicate_field("tableVersionId"));
3834                            }
3835                            table_version_id__ = 
3836                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3837                            ;
3838                        }
3839                        GeneratedField::ColumnDescs => {
3840                            if column_descs__.is_some() {
3841                                return Err(serde::de::Error::duplicate_field("columnDescs"));
3842                            }
3843                            column_descs__ = Some(map_.next_value()?);
3844                        }
3845                        GeneratedField::RateLimit => {
3846                            if rate_limit__.is_some() {
3847                                return Err(serde::de::Error::duplicate_field("rateLimit"));
3848                            }
3849                            rate_limit__ = 
3850                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3851                            ;
3852                        }
3853                    }
3854                }
3855                Ok(DmlNode {
3856                    table_id: table_id__.unwrap_or_default(),
3857                    table_version_id: table_version_id__.unwrap_or_default(),
3858                    column_descs: column_descs__.unwrap_or_default(),
3859                    rate_limit: rate_limit__,
3860                })
3861            }
3862        }
3863        deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
3864    }
3865}
3866impl serde::Serialize for DropSubscriptionsMutation {
3867    #[allow(deprecated)]
3868    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3869    where
3870        S: serde::Serializer,
3871    {
3872        use serde::ser::SerializeStruct;
3873        let mut len = 0;
3874        if !self.info.is_empty() {
3875            len += 1;
3876        }
3877        let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
3878        if !self.info.is_empty() {
3879            struct_ser.serialize_field("info", &self.info)?;
3880        }
3881        struct_ser.end()
3882    }
3883}
3884impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
3885    #[allow(deprecated)]
3886    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3887    where
3888        D: serde::Deserializer<'de>,
3889    {
3890        const FIELDS: &[&str] = &[
3891            "info",
3892        ];
3893
3894        #[allow(clippy::enum_variant_names)]
3895        enum GeneratedField {
3896            Info,
3897        }
3898        impl<'de> serde::Deserialize<'de> for GeneratedField {
3899            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3900            where
3901                D: serde::Deserializer<'de>,
3902            {
3903                struct GeneratedVisitor;
3904
3905                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3906                    type Value = GeneratedField;
3907
3908                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3909                        write!(formatter, "expected one of: {:?}", &FIELDS)
3910                    }
3911
3912                    #[allow(unused_variables)]
3913                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3914                    where
3915                        E: serde::de::Error,
3916                    {
3917                        match value {
3918                            "info" => Ok(GeneratedField::Info),
3919                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3920                        }
3921                    }
3922                }
3923                deserializer.deserialize_identifier(GeneratedVisitor)
3924            }
3925        }
3926        struct GeneratedVisitor;
3927        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3928            type Value = DropSubscriptionsMutation;
3929
3930            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3931                formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
3932            }
3933
3934            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
3935                where
3936                    V: serde::de::MapAccess<'de>,
3937            {
3938                let mut info__ = None;
3939                while let Some(k) = map_.next_key()? {
3940                    match k {
3941                        GeneratedField::Info => {
3942                            if info__.is_some() {
3943                                return Err(serde::de::Error::duplicate_field("info"));
3944                            }
3945                            info__ = Some(map_.next_value()?);
3946                        }
3947                    }
3948                }
3949                Ok(DropSubscriptionsMutation {
3950                    info: info__.unwrap_or_default(),
3951                })
3952            }
3953        }
3954        deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
3955    }
3956}
3957impl serde::Serialize for DynamicFilterNode {
3958    #[allow(deprecated)]
3959    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3960    where
3961        S: serde::Serializer,
3962    {
3963        use serde::ser::SerializeStruct;
3964        let mut len = 0;
3965        if self.left_key != 0 {
3966            len += 1;
3967        }
3968        if self.condition.is_some() {
3969            len += 1;
3970        }
3971        if self.left_table.is_some() {
3972            len += 1;
3973        }
3974        if self.right_table.is_some() {
3975            len += 1;
3976        }
3977        if self.condition_always_relax {
3978            len += 1;
3979        }
3980        let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
3981        if self.left_key != 0 {
3982            struct_ser.serialize_field("leftKey", &self.left_key)?;
3983        }
3984        if let Some(v) = self.condition.as_ref() {
3985            struct_ser.serialize_field("condition", v)?;
3986        }
3987        if let Some(v) = self.left_table.as_ref() {
3988            struct_ser.serialize_field("leftTable", v)?;
3989        }
3990        if let Some(v) = self.right_table.as_ref() {
3991            struct_ser.serialize_field("rightTable", v)?;
3992        }
3993        if self.condition_always_relax {
3994            struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
3995        }
3996        struct_ser.end()
3997    }
3998}
3999impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4000    #[allow(deprecated)]
4001    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4002    where
4003        D: serde::Deserializer<'de>,
4004    {
4005        const FIELDS: &[&str] = &[
4006            "left_key",
4007            "leftKey",
4008            "condition",
4009            "left_table",
4010            "leftTable",
4011            "right_table",
4012            "rightTable",
4013            "condition_always_relax",
4014            "conditionAlwaysRelax",
4015        ];
4016
4017        #[allow(clippy::enum_variant_names)]
4018        enum GeneratedField {
4019            LeftKey,
4020            Condition,
4021            LeftTable,
4022            RightTable,
4023            ConditionAlwaysRelax,
4024        }
4025        impl<'de> serde::Deserialize<'de> for GeneratedField {
4026            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4027            where
4028                D: serde::Deserializer<'de>,
4029            {
4030                struct GeneratedVisitor;
4031
4032                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4033                    type Value = GeneratedField;
4034
4035                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4036                        write!(formatter, "expected one of: {:?}", &FIELDS)
4037                    }
4038
4039                    #[allow(unused_variables)]
4040                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4041                    where
4042                        E: serde::de::Error,
4043                    {
4044                        match value {
4045                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4046                            "condition" => Ok(GeneratedField::Condition),
4047                            "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4048                            "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4049                            "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4050                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4051                        }
4052                    }
4053                }
4054                deserializer.deserialize_identifier(GeneratedVisitor)
4055            }
4056        }
4057        struct GeneratedVisitor;
4058        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4059            type Value = DynamicFilterNode;
4060
4061            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4062                formatter.write_str("struct stream_plan.DynamicFilterNode")
4063            }
4064
4065            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4066                where
4067                    V: serde::de::MapAccess<'de>,
4068            {
4069                let mut left_key__ = None;
4070                let mut condition__ = None;
4071                let mut left_table__ = None;
4072                let mut right_table__ = None;
4073                let mut condition_always_relax__ = None;
4074                while let Some(k) = map_.next_key()? {
4075                    match k {
4076                        GeneratedField::LeftKey => {
4077                            if left_key__.is_some() {
4078                                return Err(serde::de::Error::duplicate_field("leftKey"));
4079                            }
4080                            left_key__ = 
4081                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4082                            ;
4083                        }
4084                        GeneratedField::Condition => {
4085                            if condition__.is_some() {
4086                                return Err(serde::de::Error::duplicate_field("condition"));
4087                            }
4088                            condition__ = map_.next_value()?;
4089                        }
4090                        GeneratedField::LeftTable => {
4091                            if left_table__.is_some() {
4092                                return Err(serde::de::Error::duplicate_field("leftTable"));
4093                            }
4094                            left_table__ = map_.next_value()?;
4095                        }
4096                        GeneratedField::RightTable => {
4097                            if right_table__.is_some() {
4098                                return Err(serde::de::Error::duplicate_field("rightTable"));
4099                            }
4100                            right_table__ = map_.next_value()?;
4101                        }
4102                        GeneratedField::ConditionAlwaysRelax => {
4103                            if condition_always_relax__.is_some() {
4104                                return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4105                            }
4106                            condition_always_relax__ = Some(map_.next_value()?);
4107                        }
4108                    }
4109                }
4110                Ok(DynamicFilterNode {
4111                    left_key: left_key__.unwrap_or_default(),
4112                    condition: condition__,
4113                    left_table: left_table__,
4114                    right_table: right_table__,
4115                    condition_always_relax: condition_always_relax__.unwrap_or_default(),
4116                })
4117            }
4118        }
4119        deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4120    }
4121}
4122impl serde::Serialize for EowcOverWindowNode {
4123    #[allow(deprecated)]
4124    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4125    where
4126        S: serde::Serializer,
4127    {
4128        use serde::ser::SerializeStruct;
4129        let mut len = 0;
4130        if !self.calls.is_empty() {
4131            len += 1;
4132        }
4133        if !self.partition_by.is_empty() {
4134            len += 1;
4135        }
4136        if !self.order_by.is_empty() {
4137            len += 1;
4138        }
4139        if self.state_table.is_some() {
4140            len += 1;
4141        }
4142        let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4143        if !self.calls.is_empty() {
4144            struct_ser.serialize_field("calls", &self.calls)?;
4145        }
4146        if !self.partition_by.is_empty() {
4147            struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4148        }
4149        if !self.order_by.is_empty() {
4150            struct_ser.serialize_field("orderBy", &self.order_by)?;
4151        }
4152        if let Some(v) = self.state_table.as_ref() {
4153            struct_ser.serialize_field("stateTable", v)?;
4154        }
4155        struct_ser.end()
4156    }
4157}
4158impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4159    #[allow(deprecated)]
4160    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4161    where
4162        D: serde::Deserializer<'de>,
4163    {
4164        const FIELDS: &[&str] = &[
4165            "calls",
4166            "partition_by",
4167            "partitionBy",
4168            "order_by",
4169            "orderBy",
4170            "state_table",
4171            "stateTable",
4172        ];
4173
4174        #[allow(clippy::enum_variant_names)]
4175        enum GeneratedField {
4176            Calls,
4177            PartitionBy,
4178            OrderBy,
4179            StateTable,
4180        }
4181        impl<'de> serde::Deserialize<'de> for GeneratedField {
4182            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4183            where
4184                D: serde::Deserializer<'de>,
4185            {
4186                struct GeneratedVisitor;
4187
4188                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4189                    type Value = GeneratedField;
4190
4191                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4192                        write!(formatter, "expected one of: {:?}", &FIELDS)
4193                    }
4194
4195                    #[allow(unused_variables)]
4196                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4197                    where
4198                        E: serde::de::Error,
4199                    {
4200                        match value {
4201                            "calls" => Ok(GeneratedField::Calls),
4202                            "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4203                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4204                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4205                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4206                        }
4207                    }
4208                }
4209                deserializer.deserialize_identifier(GeneratedVisitor)
4210            }
4211        }
4212        struct GeneratedVisitor;
4213        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4214            type Value = EowcOverWindowNode;
4215
4216            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4217                formatter.write_str("struct stream_plan.EowcOverWindowNode")
4218            }
4219
4220            fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4221                where
4222                    V: serde::de::MapAccess<'de>,
4223            {
4224                let mut calls__ = None;
4225                let mut partition_by__ = None;
4226                let mut order_by__ = None;
4227                let mut state_table__ = None;
4228                while let Some(k) = map_.next_key()? {
4229                    match k {
4230                        GeneratedField::Calls => {
4231                            if calls__.is_some() {
4232                                return Err(serde::de::Error::duplicate_field("calls"));
4233                            }
4234                            calls__ = Some(map_.next_value()?);
4235                        }
4236                        GeneratedField::PartitionBy => {
4237                            if partition_by__.is_some() {
4238                                return Err(serde::de::Error::duplicate_field("partitionBy"));
4239                            }
4240                            partition_by__ = 
4241                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4242                                    .into_iter().map(|x| x.0).collect())
4243                            ;
4244                        }
4245                        GeneratedField::OrderBy => {
4246                            if order_by__.is_some() {
4247                                return Err(serde::de::Error::duplicate_field("orderBy"));
4248                            }
4249                            order_by__ = Some(map_.next_value()?);
4250                        }
4251                        GeneratedField::StateTable => {
4252                            if state_table__.is_some() {
4253                                return Err(serde::de::Error::duplicate_field("stateTable"));
4254                            }
4255                            state_table__ = map_.next_value()?;
4256                        }
4257                    }
4258                }
4259                Ok(EowcOverWindowNode {
4260                    calls: calls__.unwrap_or_default(),
4261                    partition_by: partition_by__.unwrap_or_default(),
4262                    order_by: order_by__.unwrap_or_default(),
4263                    state_table: state_table__,
4264                })
4265            }
4266        }
4267        deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4268    }
4269}
4270impl serde::Serialize for ExchangeNode {
4271    #[allow(deprecated)]
4272    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4273    where
4274        S: serde::Serializer,
4275    {
4276        use serde::ser::SerializeStruct;
4277        let mut len = 0;
4278        if self.strategy.is_some() {
4279            len += 1;
4280        }
4281        let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4282        if let Some(v) = self.strategy.as_ref() {
4283            struct_ser.serialize_field("strategy", v)?;
4284        }
4285        struct_ser.end()
4286    }
4287}
4288impl<'de> serde::Deserialize<'de> for ExchangeNode {
4289    #[allow(deprecated)]
4290    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4291    where
4292        D: serde::Deserializer<'de>,
4293    {
4294        const FIELDS: &[&str] = &[
4295            "strategy",
4296        ];
4297
4298        #[allow(clippy::enum_variant_names)]
4299        enum GeneratedField {
4300            Strategy,
4301        }
4302        impl<'de> serde::Deserialize<'de> for GeneratedField {
4303            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4304            where
4305                D: serde::Deserializer<'de>,
4306            {
4307                struct GeneratedVisitor;
4308
4309                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4310                    type Value = GeneratedField;
4311
4312                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4313                        write!(formatter, "expected one of: {:?}", &FIELDS)
4314                    }
4315
4316                    #[allow(unused_variables)]
4317                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4318                    where
4319                        E: serde::de::Error,
4320                    {
4321                        match value {
4322                            "strategy" => Ok(GeneratedField::Strategy),
4323                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4324                        }
4325                    }
4326                }
4327                deserializer.deserialize_identifier(GeneratedVisitor)
4328            }
4329        }
4330        struct GeneratedVisitor;
4331        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4332            type Value = ExchangeNode;
4333
4334            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4335                formatter.write_str("struct stream_plan.ExchangeNode")
4336            }
4337
4338            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4339                where
4340                    V: serde::de::MapAccess<'de>,
4341            {
4342                let mut strategy__ = None;
4343                while let Some(k) = map_.next_key()? {
4344                    match k {
4345                        GeneratedField::Strategy => {
4346                            if strategy__.is_some() {
4347                                return Err(serde::de::Error::duplicate_field("strategy"));
4348                            }
4349                            strategy__ = map_.next_value()?;
4350                        }
4351                    }
4352                }
4353                Ok(ExchangeNode {
4354                    strategy: strategy__,
4355                })
4356            }
4357        }
4358        deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4359    }
4360}
4361impl serde::Serialize for ExpandNode {
4362    #[allow(deprecated)]
4363    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4364    where
4365        S: serde::Serializer,
4366    {
4367        use serde::ser::SerializeStruct;
4368        let mut len = 0;
4369        if !self.column_subsets.is_empty() {
4370            len += 1;
4371        }
4372        let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4373        if !self.column_subsets.is_empty() {
4374            struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4375        }
4376        struct_ser.end()
4377    }
4378}
4379impl<'de> serde::Deserialize<'de> for ExpandNode {
4380    #[allow(deprecated)]
4381    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4382    where
4383        D: serde::Deserializer<'de>,
4384    {
4385        const FIELDS: &[&str] = &[
4386            "column_subsets",
4387            "columnSubsets",
4388        ];
4389
4390        #[allow(clippy::enum_variant_names)]
4391        enum GeneratedField {
4392            ColumnSubsets,
4393        }
4394        impl<'de> serde::Deserialize<'de> for GeneratedField {
4395            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4396            where
4397                D: serde::Deserializer<'de>,
4398            {
4399                struct GeneratedVisitor;
4400
4401                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4402                    type Value = GeneratedField;
4403
4404                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4405                        write!(formatter, "expected one of: {:?}", &FIELDS)
4406                    }
4407
4408                    #[allow(unused_variables)]
4409                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4410                    where
4411                        E: serde::de::Error,
4412                    {
4413                        match value {
4414                            "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4415                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4416                        }
4417                    }
4418                }
4419                deserializer.deserialize_identifier(GeneratedVisitor)
4420            }
4421        }
4422        struct GeneratedVisitor;
4423        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4424            type Value = ExpandNode;
4425
4426            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4427                formatter.write_str("struct stream_plan.ExpandNode")
4428            }
4429
4430            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4431                where
4432                    V: serde::de::MapAccess<'de>,
4433            {
4434                let mut column_subsets__ = None;
4435                while let Some(k) = map_.next_key()? {
4436                    match k {
4437                        GeneratedField::ColumnSubsets => {
4438                            if column_subsets__.is_some() {
4439                                return Err(serde::de::Error::duplicate_field("columnSubsets"));
4440                            }
4441                            column_subsets__ = Some(map_.next_value()?);
4442                        }
4443                    }
4444                }
4445                Ok(ExpandNode {
4446                    column_subsets: column_subsets__.unwrap_or_default(),
4447                })
4448            }
4449        }
4450        deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4451    }
4452}
4453impl serde::Serialize for expand_node::Subset {
4454    #[allow(deprecated)]
4455    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4456    where
4457        S: serde::Serializer,
4458    {
4459        use serde::ser::SerializeStruct;
4460        let mut len = 0;
4461        if !self.column_indices.is_empty() {
4462            len += 1;
4463        }
4464        let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4465        if !self.column_indices.is_empty() {
4466            struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4467        }
4468        struct_ser.end()
4469    }
4470}
4471impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4472    #[allow(deprecated)]
4473    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4474    where
4475        D: serde::Deserializer<'de>,
4476    {
4477        const FIELDS: &[&str] = &[
4478            "column_indices",
4479            "columnIndices",
4480        ];
4481
4482        #[allow(clippy::enum_variant_names)]
4483        enum GeneratedField {
4484            ColumnIndices,
4485        }
4486        impl<'de> serde::Deserialize<'de> for GeneratedField {
4487            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4488            where
4489                D: serde::Deserializer<'de>,
4490            {
4491                struct GeneratedVisitor;
4492
4493                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4494                    type Value = GeneratedField;
4495
4496                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4497                        write!(formatter, "expected one of: {:?}", &FIELDS)
4498                    }
4499
4500                    #[allow(unused_variables)]
4501                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4502                    where
4503                        E: serde::de::Error,
4504                    {
4505                        match value {
4506                            "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4507                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4508                        }
4509                    }
4510                }
4511                deserializer.deserialize_identifier(GeneratedVisitor)
4512            }
4513        }
4514        struct GeneratedVisitor;
4515        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4516            type Value = expand_node::Subset;
4517
4518            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4519                formatter.write_str("struct stream_plan.ExpandNode.Subset")
4520            }
4521
4522            fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
4523                where
4524                    V: serde::de::MapAccess<'de>,
4525            {
4526                let mut column_indices__ = None;
4527                while let Some(k) = map_.next_key()? {
4528                    match k {
4529                        GeneratedField::ColumnIndices => {
4530                            if column_indices__.is_some() {
4531                                return Err(serde::de::Error::duplicate_field("columnIndices"));
4532                            }
4533                            column_indices__ = 
4534                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4535                                    .into_iter().map(|x| x.0).collect())
4536                            ;
4537                        }
4538                    }
4539                }
4540                Ok(expand_node::Subset {
4541                    column_indices: column_indices__.unwrap_or_default(),
4542                })
4543            }
4544        }
4545        deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
4546    }
4547}
4548impl serde::Serialize for FilterNode {
4549    #[allow(deprecated)]
4550    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4551    where
4552        S: serde::Serializer,
4553    {
4554        use serde::ser::SerializeStruct;
4555        let mut len = 0;
4556        if self.search_condition.is_some() {
4557            len += 1;
4558        }
4559        let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
4560        if let Some(v) = self.search_condition.as_ref() {
4561            struct_ser.serialize_field("searchCondition", v)?;
4562        }
4563        struct_ser.end()
4564    }
4565}
4566impl<'de> serde::Deserialize<'de> for FilterNode {
4567    #[allow(deprecated)]
4568    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4569    where
4570        D: serde::Deserializer<'de>,
4571    {
4572        const FIELDS: &[&str] = &[
4573            "search_condition",
4574            "searchCondition",
4575        ];
4576
4577        #[allow(clippy::enum_variant_names)]
4578        enum GeneratedField {
4579            SearchCondition,
4580        }
4581        impl<'de> serde::Deserialize<'de> for GeneratedField {
4582            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4583            where
4584                D: serde::Deserializer<'de>,
4585            {
4586                struct GeneratedVisitor;
4587
4588                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4589                    type Value = GeneratedField;
4590
4591                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4592                        write!(formatter, "expected one of: {:?}", &FIELDS)
4593                    }
4594
4595                    #[allow(unused_variables)]
4596                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4597                    where
4598                        E: serde::de::Error,
4599                    {
4600                        match value {
4601                            "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
4602                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4603                        }
4604                    }
4605                }
4606                deserializer.deserialize_identifier(GeneratedVisitor)
4607            }
4608        }
4609        struct GeneratedVisitor;
4610        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4611            type Value = FilterNode;
4612
4613            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4614                formatter.write_str("struct stream_plan.FilterNode")
4615            }
4616
4617            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
4618                where
4619                    V: serde::de::MapAccess<'de>,
4620            {
4621                let mut search_condition__ = None;
4622                while let Some(k) = map_.next_key()? {
4623                    match k {
4624                        GeneratedField::SearchCondition => {
4625                            if search_condition__.is_some() {
4626                                return Err(serde::de::Error::duplicate_field("searchCondition"));
4627                            }
4628                            search_condition__ = map_.next_value()?;
4629                        }
4630                    }
4631                }
4632                Ok(FilterNode {
4633                    search_condition: search_condition__,
4634                })
4635            }
4636        }
4637        deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
4638    }
4639}
4640impl serde::Serialize for GlobalApproxPercentileNode {
4641    #[allow(deprecated)]
4642    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4643    where
4644        S: serde::Serializer,
4645    {
4646        use serde::ser::SerializeStruct;
4647        let mut len = 0;
4648        if self.base != 0. {
4649            len += 1;
4650        }
4651        if self.quantile != 0. {
4652            len += 1;
4653        }
4654        if self.bucket_state_table.is_some() {
4655            len += 1;
4656        }
4657        if self.count_state_table.is_some() {
4658            len += 1;
4659        }
4660        let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
4661        if self.base != 0. {
4662            struct_ser.serialize_field("base", &self.base)?;
4663        }
4664        if self.quantile != 0. {
4665            struct_ser.serialize_field("quantile", &self.quantile)?;
4666        }
4667        if let Some(v) = self.bucket_state_table.as_ref() {
4668            struct_ser.serialize_field("bucketStateTable", v)?;
4669        }
4670        if let Some(v) = self.count_state_table.as_ref() {
4671            struct_ser.serialize_field("countStateTable", v)?;
4672        }
4673        struct_ser.end()
4674    }
4675}
4676impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
4677    #[allow(deprecated)]
4678    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4679    where
4680        D: serde::Deserializer<'de>,
4681    {
4682        const FIELDS: &[&str] = &[
4683            "base",
4684            "quantile",
4685            "bucket_state_table",
4686            "bucketStateTable",
4687            "count_state_table",
4688            "countStateTable",
4689        ];
4690
4691        #[allow(clippy::enum_variant_names)]
4692        enum GeneratedField {
4693            Base,
4694            Quantile,
4695            BucketStateTable,
4696            CountStateTable,
4697        }
4698        impl<'de> serde::Deserialize<'de> for GeneratedField {
4699            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4700            where
4701                D: serde::Deserializer<'de>,
4702            {
4703                struct GeneratedVisitor;
4704
4705                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4706                    type Value = GeneratedField;
4707
4708                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4709                        write!(formatter, "expected one of: {:?}", &FIELDS)
4710                    }
4711
4712                    #[allow(unused_variables)]
4713                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4714                    where
4715                        E: serde::de::Error,
4716                    {
4717                        match value {
4718                            "base" => Ok(GeneratedField::Base),
4719                            "quantile" => Ok(GeneratedField::Quantile),
4720                            "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
4721                            "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
4722                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4723                        }
4724                    }
4725                }
4726                deserializer.deserialize_identifier(GeneratedVisitor)
4727            }
4728        }
4729        struct GeneratedVisitor;
4730        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4731            type Value = GlobalApproxPercentileNode;
4732
4733            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4734                formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
4735            }
4736
4737            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
4738                where
4739                    V: serde::de::MapAccess<'de>,
4740            {
4741                let mut base__ = None;
4742                let mut quantile__ = None;
4743                let mut bucket_state_table__ = None;
4744                let mut count_state_table__ = None;
4745                while let Some(k) = map_.next_key()? {
4746                    match k {
4747                        GeneratedField::Base => {
4748                            if base__.is_some() {
4749                                return Err(serde::de::Error::duplicate_field("base"));
4750                            }
4751                            base__ = 
4752                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4753                            ;
4754                        }
4755                        GeneratedField::Quantile => {
4756                            if quantile__.is_some() {
4757                                return Err(serde::de::Error::duplicate_field("quantile"));
4758                            }
4759                            quantile__ = 
4760                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4761                            ;
4762                        }
4763                        GeneratedField::BucketStateTable => {
4764                            if bucket_state_table__.is_some() {
4765                                return Err(serde::de::Error::duplicate_field("bucketStateTable"));
4766                            }
4767                            bucket_state_table__ = map_.next_value()?;
4768                        }
4769                        GeneratedField::CountStateTable => {
4770                            if count_state_table__.is_some() {
4771                                return Err(serde::de::Error::duplicate_field("countStateTable"));
4772                            }
4773                            count_state_table__ = map_.next_value()?;
4774                        }
4775                    }
4776                }
4777                Ok(GlobalApproxPercentileNode {
4778                    base: base__.unwrap_or_default(),
4779                    quantile: quantile__.unwrap_or_default(),
4780                    bucket_state_table: bucket_state_table__,
4781                    count_state_table: count_state_table__,
4782                })
4783            }
4784        }
4785        deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
4786    }
4787}
4788impl serde::Serialize for GroupTopNNode {
4789    #[allow(deprecated)]
4790    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4791    where
4792        S: serde::Serializer,
4793    {
4794        use serde::ser::SerializeStruct;
4795        let mut len = 0;
4796        if self.limit != 0 {
4797            len += 1;
4798        }
4799        if self.offset != 0 {
4800            len += 1;
4801        }
4802        if !self.group_key.is_empty() {
4803            len += 1;
4804        }
4805        if self.table.is_some() {
4806            len += 1;
4807        }
4808        if !self.order_by.is_empty() {
4809            len += 1;
4810        }
4811        if self.with_ties {
4812            len += 1;
4813        }
4814        let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
4815        if self.limit != 0 {
4816            #[allow(clippy::needless_borrow)]
4817            #[allow(clippy::needless_borrows_for_generic_args)]
4818            struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
4819        }
4820        if self.offset != 0 {
4821            #[allow(clippy::needless_borrow)]
4822            #[allow(clippy::needless_borrows_for_generic_args)]
4823            struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
4824        }
4825        if !self.group_key.is_empty() {
4826            struct_ser.serialize_field("groupKey", &self.group_key)?;
4827        }
4828        if let Some(v) = self.table.as_ref() {
4829            struct_ser.serialize_field("table", v)?;
4830        }
4831        if !self.order_by.is_empty() {
4832            struct_ser.serialize_field("orderBy", &self.order_by)?;
4833        }
4834        if self.with_ties {
4835            struct_ser.serialize_field("withTies", &self.with_ties)?;
4836        }
4837        struct_ser.end()
4838    }
4839}
4840impl<'de> serde::Deserialize<'de> for GroupTopNNode {
4841    #[allow(deprecated)]
4842    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4843    where
4844        D: serde::Deserializer<'de>,
4845    {
4846        const FIELDS: &[&str] = &[
4847            "limit",
4848            "offset",
4849            "group_key",
4850            "groupKey",
4851            "table",
4852            "order_by",
4853            "orderBy",
4854            "with_ties",
4855            "withTies",
4856        ];
4857
4858        #[allow(clippy::enum_variant_names)]
4859        enum GeneratedField {
4860            Limit,
4861            Offset,
4862            GroupKey,
4863            Table,
4864            OrderBy,
4865            WithTies,
4866        }
4867        impl<'de> serde::Deserialize<'de> for GeneratedField {
4868            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4869            where
4870                D: serde::Deserializer<'de>,
4871            {
4872                struct GeneratedVisitor;
4873
4874                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4875                    type Value = GeneratedField;
4876
4877                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4878                        write!(formatter, "expected one of: {:?}", &FIELDS)
4879                    }
4880
4881                    #[allow(unused_variables)]
4882                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4883                    where
4884                        E: serde::de::Error,
4885                    {
4886                        match value {
4887                            "limit" => Ok(GeneratedField::Limit),
4888                            "offset" => Ok(GeneratedField::Offset),
4889                            "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
4890                            "table" => Ok(GeneratedField::Table),
4891                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4892                            "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
4893                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4894                        }
4895                    }
4896                }
4897                deserializer.deserialize_identifier(GeneratedVisitor)
4898            }
4899        }
4900        struct GeneratedVisitor;
4901        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4902            type Value = GroupTopNNode;
4903
4904            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4905                formatter.write_str("struct stream_plan.GroupTopNNode")
4906            }
4907
4908            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
4909                where
4910                    V: serde::de::MapAccess<'de>,
4911            {
4912                let mut limit__ = None;
4913                let mut offset__ = None;
4914                let mut group_key__ = None;
4915                let mut table__ = None;
4916                let mut order_by__ = None;
4917                let mut with_ties__ = None;
4918                while let Some(k) = map_.next_key()? {
4919                    match k {
4920                        GeneratedField::Limit => {
4921                            if limit__.is_some() {
4922                                return Err(serde::de::Error::duplicate_field("limit"));
4923                            }
4924                            limit__ = 
4925                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4926                            ;
4927                        }
4928                        GeneratedField::Offset => {
4929                            if offset__.is_some() {
4930                                return Err(serde::de::Error::duplicate_field("offset"));
4931                            }
4932                            offset__ = 
4933                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4934                            ;
4935                        }
4936                        GeneratedField::GroupKey => {
4937                            if group_key__.is_some() {
4938                                return Err(serde::de::Error::duplicate_field("groupKey"));
4939                            }
4940                            group_key__ = 
4941                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4942                                    .into_iter().map(|x| x.0).collect())
4943                            ;
4944                        }
4945                        GeneratedField::Table => {
4946                            if table__.is_some() {
4947                                return Err(serde::de::Error::duplicate_field("table"));
4948                            }
4949                            table__ = map_.next_value()?;
4950                        }
4951                        GeneratedField::OrderBy => {
4952                            if order_by__.is_some() {
4953                                return Err(serde::de::Error::duplicate_field("orderBy"));
4954                            }
4955                            order_by__ = Some(map_.next_value()?);
4956                        }
4957                        GeneratedField::WithTies => {
4958                            if with_ties__.is_some() {
4959                                return Err(serde::de::Error::duplicate_field("withTies"));
4960                            }
4961                            with_ties__ = Some(map_.next_value()?);
4962                        }
4963                    }
4964                }
4965                Ok(GroupTopNNode {
4966                    limit: limit__.unwrap_or_default(),
4967                    offset: offset__.unwrap_or_default(),
4968                    group_key: group_key__.unwrap_or_default(),
4969                    table: table__,
4970                    order_by: order_by__.unwrap_or_default(),
4971                    with_ties: with_ties__.unwrap_or_default(),
4972                })
4973            }
4974        }
4975        deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
4976    }
4977}
4978impl serde::Serialize for HashAggNode {
4979    #[allow(deprecated)]
4980    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4981    where
4982        S: serde::Serializer,
4983    {
4984        use serde::ser::SerializeStruct;
4985        let mut len = 0;
4986        if !self.group_key.is_empty() {
4987            len += 1;
4988        }
4989        if !self.agg_calls.is_empty() {
4990            len += 1;
4991        }
4992        if !self.agg_call_states.is_empty() {
4993            len += 1;
4994        }
4995        if self.intermediate_state_table.is_some() {
4996            len += 1;
4997        }
4998        if self.is_append_only {
4999            len += 1;
5000        }
5001        if !self.distinct_dedup_tables.is_empty() {
5002            len += 1;
5003        }
5004        if self.row_count_index != 0 {
5005            len += 1;
5006        }
5007        if self.emit_on_window_close {
5008            len += 1;
5009        }
5010        if self.version != 0 {
5011            len += 1;
5012        }
5013        let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
5014        if !self.group_key.is_empty() {
5015            struct_ser.serialize_field("groupKey", &self.group_key)?;
5016        }
5017        if !self.agg_calls.is_empty() {
5018            struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
5019        }
5020        if !self.agg_call_states.is_empty() {
5021            struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5022        }
5023        if let Some(v) = self.intermediate_state_table.as_ref() {
5024            struct_ser.serialize_field("intermediateStateTable", v)?;
5025        }
5026        if self.is_append_only {
5027            struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5028        }
5029        if !self.distinct_dedup_tables.is_empty() {
5030            struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5031        }
5032        if self.row_count_index != 0 {
5033            struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5034        }
5035        if self.emit_on_window_close {
5036            struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5037        }
5038        if self.version != 0 {
5039            let v = AggNodeVersion::try_from(self.version)
5040                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5041            struct_ser.serialize_field("version", &v)?;
5042        }
5043        struct_ser.end()
5044    }
5045}
5046impl<'de> serde::Deserialize<'de> for HashAggNode {
5047    #[allow(deprecated)]
5048    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5049    where
5050        D: serde::Deserializer<'de>,
5051    {
5052        const FIELDS: &[&str] = &[
5053            "group_key",
5054            "groupKey",
5055            "agg_calls",
5056            "aggCalls",
5057            "agg_call_states",
5058            "aggCallStates",
5059            "intermediate_state_table",
5060            "intermediateStateTable",
5061            "is_append_only",
5062            "isAppendOnly",
5063            "distinct_dedup_tables",
5064            "distinctDedupTables",
5065            "row_count_index",
5066            "rowCountIndex",
5067            "emit_on_window_close",
5068            "emitOnWindowClose",
5069            "version",
5070        ];
5071
5072        #[allow(clippy::enum_variant_names)]
5073        enum GeneratedField {
5074            GroupKey,
5075            AggCalls,
5076            AggCallStates,
5077            IntermediateStateTable,
5078            IsAppendOnly,
5079            DistinctDedupTables,
5080            RowCountIndex,
5081            EmitOnWindowClose,
5082            Version,
5083        }
5084        impl<'de> serde::Deserialize<'de> for GeneratedField {
5085            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5086            where
5087                D: serde::Deserializer<'de>,
5088            {
5089                struct GeneratedVisitor;
5090
5091                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5092                    type Value = GeneratedField;
5093
5094                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5095                        write!(formatter, "expected one of: {:?}", &FIELDS)
5096                    }
5097
5098                    #[allow(unused_variables)]
5099                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5100                    where
5101                        E: serde::de::Error,
5102                    {
5103                        match value {
5104                            "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5105                            "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
5106                            "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
5107                            "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5108                            "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5109                            "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
5110                            "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
5111                            "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
5112                            "version" => Ok(GeneratedField::Version),
5113                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5114                        }
5115                    }
5116                }
5117                deserializer.deserialize_identifier(GeneratedVisitor)
5118            }
5119        }
5120        struct GeneratedVisitor;
5121        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5122            type Value = HashAggNode;
5123
5124            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5125                formatter.write_str("struct stream_plan.HashAggNode")
5126            }
5127
5128            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5129                where
5130                    V: serde::de::MapAccess<'de>,
5131            {
5132                let mut group_key__ = None;
5133                let mut agg_calls__ = None;
5134                let mut agg_call_states__ = None;
5135                let mut intermediate_state_table__ = None;
5136                let mut is_append_only__ = None;
5137                let mut distinct_dedup_tables__ = None;
5138                let mut row_count_index__ = None;
5139                let mut emit_on_window_close__ = None;
5140                let mut version__ = None;
5141                while let Some(k) = map_.next_key()? {
5142                    match k {
5143                        GeneratedField::GroupKey => {
5144                            if group_key__.is_some() {
5145                                return Err(serde::de::Error::duplicate_field("groupKey"));
5146                            }
5147                            group_key__ = 
5148                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5149                                    .into_iter().map(|x| x.0).collect())
5150                            ;
5151                        }
5152                        GeneratedField::AggCalls => {
5153                            if agg_calls__.is_some() {
5154                                return Err(serde::de::Error::duplicate_field("aggCalls"));
5155                            }
5156                            agg_calls__ = Some(map_.next_value()?);
5157                        }
5158                        GeneratedField::AggCallStates => {
5159                            if agg_call_states__.is_some() {
5160                                return Err(serde::de::Error::duplicate_field("aggCallStates"));
5161                            }
5162                            agg_call_states__ = Some(map_.next_value()?);
5163                        }
5164                        GeneratedField::IntermediateStateTable => {
5165                            if intermediate_state_table__.is_some() {
5166                                return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5167                            }
5168                            intermediate_state_table__ = map_.next_value()?;
5169                        }
5170                        GeneratedField::IsAppendOnly => {
5171                            if is_append_only__.is_some() {
5172                                return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5173                            }
5174                            is_append_only__ = Some(map_.next_value()?);
5175                        }
5176                        GeneratedField::DistinctDedupTables => {
5177                            if distinct_dedup_tables__.is_some() {
5178                                return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5179                            }
5180                            distinct_dedup_tables__ = Some(
5181                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5182                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
5183                            );
5184                        }
5185                        GeneratedField::RowCountIndex => {
5186                            if row_count_index__.is_some() {
5187                                return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5188                            }
5189                            row_count_index__ = 
5190                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5191                            ;
5192                        }
5193                        GeneratedField::EmitOnWindowClose => {
5194                            if emit_on_window_close__.is_some() {
5195                                return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5196                            }
5197                            emit_on_window_close__ = Some(map_.next_value()?);
5198                        }
5199                        GeneratedField::Version => {
5200                            if version__.is_some() {
5201                                return Err(serde::de::Error::duplicate_field("version"));
5202                            }
5203                            version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5204                        }
5205                    }
5206                }
5207                Ok(HashAggNode {
5208                    group_key: group_key__.unwrap_or_default(),
5209                    agg_calls: agg_calls__.unwrap_or_default(),
5210                    agg_call_states: agg_call_states__.unwrap_or_default(),
5211                    intermediate_state_table: intermediate_state_table__,
5212                    is_append_only: is_append_only__.unwrap_or_default(),
5213                    distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5214                    row_count_index: row_count_index__.unwrap_or_default(),
5215                    emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5216                    version: version__.unwrap_or_default(),
5217                })
5218            }
5219        }
5220        deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5221    }
5222}
5223impl serde::Serialize for HashJoinNode {
5224    #[allow(deprecated)]
5225    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5226    where
5227        S: serde::Serializer,
5228    {
5229        use serde::ser::SerializeStruct;
5230        let mut len = 0;
5231        if self.join_type != 0 {
5232            len += 1;
5233        }
5234        if !self.left_key.is_empty() {
5235            len += 1;
5236        }
5237        if !self.right_key.is_empty() {
5238            len += 1;
5239        }
5240        if self.condition.is_some() {
5241            len += 1;
5242        }
5243        if !self.inequality_pairs.is_empty() {
5244            len += 1;
5245        }
5246        if self.left_table.is_some() {
5247            len += 1;
5248        }
5249        if self.right_table.is_some() {
5250            len += 1;
5251        }
5252        if self.left_degree_table.is_some() {
5253            len += 1;
5254        }
5255        if self.right_degree_table.is_some() {
5256            len += 1;
5257        }
5258        if !self.output_indices.is_empty() {
5259            len += 1;
5260        }
5261        if !self.left_deduped_input_pk_indices.is_empty() {
5262            len += 1;
5263        }
5264        if !self.right_deduped_input_pk_indices.is_empty() {
5265            len += 1;
5266        }
5267        if !self.null_safe.is_empty() {
5268            len += 1;
5269        }
5270        if self.is_append_only {
5271            len += 1;
5272        }
5273        if self.join_encoding_type != 0 {
5274            len += 1;
5275        }
5276        let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5277        if self.join_type != 0 {
5278            let v = super::plan_common::JoinType::try_from(self.join_type)
5279                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5280            struct_ser.serialize_field("joinType", &v)?;
5281        }
5282        if !self.left_key.is_empty() {
5283            struct_ser.serialize_field("leftKey", &self.left_key)?;
5284        }
5285        if !self.right_key.is_empty() {
5286            struct_ser.serialize_field("rightKey", &self.right_key)?;
5287        }
5288        if let Some(v) = self.condition.as_ref() {
5289            struct_ser.serialize_field("condition", v)?;
5290        }
5291        if !self.inequality_pairs.is_empty() {
5292            struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
5293        }
5294        if let Some(v) = self.left_table.as_ref() {
5295            struct_ser.serialize_field("leftTable", v)?;
5296        }
5297        if let Some(v) = self.right_table.as_ref() {
5298            struct_ser.serialize_field("rightTable", v)?;
5299        }
5300        if let Some(v) = self.left_degree_table.as_ref() {
5301            struct_ser.serialize_field("leftDegreeTable", v)?;
5302        }
5303        if let Some(v) = self.right_degree_table.as_ref() {
5304            struct_ser.serialize_field("rightDegreeTable", v)?;
5305        }
5306        if !self.output_indices.is_empty() {
5307            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5308        }
5309        if !self.left_deduped_input_pk_indices.is_empty() {
5310            struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
5311        }
5312        if !self.right_deduped_input_pk_indices.is_empty() {
5313            struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
5314        }
5315        if !self.null_safe.is_empty() {
5316            struct_ser.serialize_field("nullSafe", &self.null_safe)?;
5317        }
5318        if self.is_append_only {
5319            struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5320        }
5321        if self.join_encoding_type != 0 {
5322            let v = JoinEncodingType::try_from(self.join_encoding_type)
5323                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
5324            struct_ser.serialize_field("joinEncodingType", &v)?;
5325        }
5326        struct_ser.end()
5327    }
5328}
5329impl<'de> serde::Deserialize<'de> for HashJoinNode {
5330    #[allow(deprecated)]
5331    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5332    where
5333        D: serde::Deserializer<'de>,
5334    {
5335        const FIELDS: &[&str] = &[
5336            "join_type",
5337            "joinType",
5338            "left_key",
5339            "leftKey",
5340            "right_key",
5341            "rightKey",
5342            "condition",
5343            "inequality_pairs",
5344            "inequalityPairs",
5345            "left_table",
5346            "leftTable",
5347            "right_table",
5348            "rightTable",
5349            "left_degree_table",
5350            "leftDegreeTable",
5351            "right_degree_table",
5352            "rightDegreeTable",
5353            "output_indices",
5354            "outputIndices",
5355            "left_deduped_input_pk_indices",
5356            "leftDedupedInputPkIndices",
5357            "right_deduped_input_pk_indices",
5358            "rightDedupedInputPkIndices",
5359            "null_safe",
5360            "nullSafe",
5361            "is_append_only",
5362            "isAppendOnly",
5363            "join_encoding_type",
5364            "joinEncodingType",
5365        ];
5366
5367        #[allow(clippy::enum_variant_names)]
5368        enum GeneratedField {
5369            JoinType,
5370            LeftKey,
5371            RightKey,
5372            Condition,
5373            InequalityPairs,
5374            LeftTable,
5375            RightTable,
5376            LeftDegreeTable,
5377            RightDegreeTable,
5378            OutputIndices,
5379            LeftDedupedInputPkIndices,
5380            RightDedupedInputPkIndices,
5381            NullSafe,
5382            IsAppendOnly,
5383            JoinEncodingType,
5384        }
5385        impl<'de> serde::Deserialize<'de> for GeneratedField {
5386            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5387            where
5388                D: serde::Deserializer<'de>,
5389            {
5390                struct GeneratedVisitor;
5391
5392                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5393                    type Value = GeneratedField;
5394
5395                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5396                        write!(formatter, "expected one of: {:?}", &FIELDS)
5397                    }
5398
5399                    #[allow(unused_variables)]
5400                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5401                    where
5402                        E: serde::de::Error,
5403                    {
5404                        match value {
5405                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
5406                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
5407                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
5408                            "condition" => Ok(GeneratedField::Condition),
5409                            "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
5410                            "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
5411                            "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
5412                            "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
5413                            "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
5414                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5415                            "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
5416                            "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
5417                            "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
5418                            "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5419                            "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
5420                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5421                        }
5422                    }
5423                }
5424                deserializer.deserialize_identifier(GeneratedVisitor)
5425            }
5426        }
5427        struct GeneratedVisitor;
5428        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5429            type Value = HashJoinNode;
5430
5431            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5432                formatter.write_str("struct stream_plan.HashJoinNode")
5433            }
5434
5435            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
5436                where
5437                    V: serde::de::MapAccess<'de>,
5438            {
5439                let mut join_type__ = None;
5440                let mut left_key__ = None;
5441                let mut right_key__ = None;
5442                let mut condition__ = None;
5443                let mut inequality_pairs__ = None;
5444                let mut left_table__ = None;
5445                let mut right_table__ = None;
5446                let mut left_degree_table__ = None;
5447                let mut right_degree_table__ = None;
5448                let mut output_indices__ = None;
5449                let mut left_deduped_input_pk_indices__ = None;
5450                let mut right_deduped_input_pk_indices__ = None;
5451                let mut null_safe__ = None;
5452                let mut is_append_only__ = None;
5453                let mut join_encoding_type__ = None;
5454                while let Some(k) = map_.next_key()? {
5455                    match k {
5456                        GeneratedField::JoinType => {
5457                            if join_type__.is_some() {
5458                                return Err(serde::de::Error::duplicate_field("joinType"));
5459                            }
5460                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
5461                        }
5462                        GeneratedField::LeftKey => {
5463                            if left_key__.is_some() {
5464                                return Err(serde::de::Error::duplicate_field("leftKey"));
5465                            }
5466                            left_key__ = 
5467                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5468                                    .into_iter().map(|x| x.0).collect())
5469                            ;
5470                        }
5471                        GeneratedField::RightKey => {
5472                            if right_key__.is_some() {
5473                                return Err(serde::de::Error::duplicate_field("rightKey"));
5474                            }
5475                            right_key__ = 
5476                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5477                                    .into_iter().map(|x| x.0).collect())
5478                            ;
5479                        }
5480                        GeneratedField::Condition => {
5481                            if condition__.is_some() {
5482                                return Err(serde::de::Error::duplicate_field("condition"));
5483                            }
5484                            condition__ = map_.next_value()?;
5485                        }
5486                        GeneratedField::InequalityPairs => {
5487                            if inequality_pairs__.is_some() {
5488                                return Err(serde::de::Error::duplicate_field("inequalityPairs"));
5489                            }
5490                            inequality_pairs__ = Some(map_.next_value()?);
5491                        }
5492                        GeneratedField::LeftTable => {
5493                            if left_table__.is_some() {
5494                                return Err(serde::de::Error::duplicate_field("leftTable"));
5495                            }
5496                            left_table__ = map_.next_value()?;
5497                        }
5498                        GeneratedField::RightTable => {
5499                            if right_table__.is_some() {
5500                                return Err(serde::de::Error::duplicate_field("rightTable"));
5501                            }
5502                            right_table__ = map_.next_value()?;
5503                        }
5504                        GeneratedField::LeftDegreeTable => {
5505                            if left_degree_table__.is_some() {
5506                                return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
5507                            }
5508                            left_degree_table__ = map_.next_value()?;
5509                        }
5510                        GeneratedField::RightDegreeTable => {
5511                            if right_degree_table__.is_some() {
5512                                return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
5513                            }
5514                            right_degree_table__ = map_.next_value()?;
5515                        }
5516                        GeneratedField::OutputIndices => {
5517                            if output_indices__.is_some() {
5518                                return Err(serde::de::Error::duplicate_field("outputIndices"));
5519                            }
5520                            output_indices__ = 
5521                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5522                                    .into_iter().map(|x| x.0).collect())
5523                            ;
5524                        }
5525                        GeneratedField::LeftDedupedInputPkIndices => {
5526                            if left_deduped_input_pk_indices__.is_some() {
5527                                return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
5528                            }
5529                            left_deduped_input_pk_indices__ = 
5530                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5531                                    .into_iter().map(|x| x.0).collect())
5532                            ;
5533                        }
5534                        GeneratedField::RightDedupedInputPkIndices => {
5535                            if right_deduped_input_pk_indices__.is_some() {
5536                                return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
5537                            }
5538                            right_deduped_input_pk_indices__ = 
5539                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5540                                    .into_iter().map(|x| x.0).collect())
5541                            ;
5542                        }
5543                        GeneratedField::NullSafe => {
5544                            if null_safe__.is_some() {
5545                                return Err(serde::de::Error::duplicate_field("nullSafe"));
5546                            }
5547                            null_safe__ = Some(map_.next_value()?);
5548                        }
5549                        GeneratedField::IsAppendOnly => {
5550                            if is_append_only__.is_some() {
5551                                return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5552                            }
5553                            is_append_only__ = Some(map_.next_value()?);
5554                        }
5555                        GeneratedField::JoinEncodingType => {
5556                            if join_encoding_type__.is_some() {
5557                                return Err(serde::de::Error::duplicate_field("joinEncodingType"));
5558                            }
5559                            join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
5560                        }
5561                    }
5562                }
5563                Ok(HashJoinNode {
5564                    join_type: join_type__.unwrap_or_default(),
5565                    left_key: left_key__.unwrap_or_default(),
5566                    right_key: right_key__.unwrap_or_default(),
5567                    condition: condition__,
5568                    inequality_pairs: inequality_pairs__.unwrap_or_default(),
5569                    left_table: left_table__,
5570                    right_table: right_table__,
5571                    left_degree_table: left_degree_table__,
5572                    right_degree_table: right_degree_table__,
5573                    output_indices: output_indices__.unwrap_or_default(),
5574                    left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
5575                    right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
5576                    null_safe: null_safe__.unwrap_or_default(),
5577                    is_append_only: is_append_only__.unwrap_or_default(),
5578                    join_encoding_type: join_encoding_type__.unwrap_or_default(),
5579                })
5580            }
5581        }
5582        deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
5583    }
5584}
5585impl serde::Serialize for HopWindowNode {
5586    #[allow(deprecated)]
5587    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5588    where
5589        S: serde::Serializer,
5590    {
5591        use serde::ser::SerializeStruct;
5592        let mut len = 0;
5593        if self.time_col != 0 {
5594            len += 1;
5595        }
5596        if self.window_slide.is_some() {
5597            len += 1;
5598        }
5599        if self.window_size.is_some() {
5600            len += 1;
5601        }
5602        if !self.output_indices.is_empty() {
5603            len += 1;
5604        }
5605        if !self.window_start_exprs.is_empty() {
5606            len += 1;
5607        }
5608        if !self.window_end_exprs.is_empty() {
5609            len += 1;
5610        }
5611        let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
5612        if self.time_col != 0 {
5613            struct_ser.serialize_field("timeCol", &self.time_col)?;
5614        }
5615        if let Some(v) = self.window_slide.as_ref() {
5616            struct_ser.serialize_field("windowSlide", v)?;
5617        }
5618        if let Some(v) = self.window_size.as_ref() {
5619            struct_ser.serialize_field("windowSize", v)?;
5620        }
5621        if !self.output_indices.is_empty() {
5622            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5623        }
5624        if !self.window_start_exprs.is_empty() {
5625            struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
5626        }
5627        if !self.window_end_exprs.is_empty() {
5628            struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
5629        }
5630        struct_ser.end()
5631    }
5632}
5633impl<'de> serde::Deserialize<'de> for HopWindowNode {
5634    #[allow(deprecated)]
5635    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5636    where
5637        D: serde::Deserializer<'de>,
5638    {
5639        const FIELDS: &[&str] = &[
5640            "time_col",
5641            "timeCol",
5642            "window_slide",
5643            "windowSlide",
5644            "window_size",
5645            "windowSize",
5646            "output_indices",
5647            "outputIndices",
5648            "window_start_exprs",
5649            "windowStartExprs",
5650            "window_end_exprs",
5651            "windowEndExprs",
5652        ];
5653
5654        #[allow(clippy::enum_variant_names)]
5655        enum GeneratedField {
5656            TimeCol,
5657            WindowSlide,
5658            WindowSize,
5659            OutputIndices,
5660            WindowStartExprs,
5661            WindowEndExprs,
5662        }
5663        impl<'de> serde::Deserialize<'de> for GeneratedField {
5664            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5665            where
5666                D: serde::Deserializer<'de>,
5667            {
5668                struct GeneratedVisitor;
5669
5670                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5671                    type Value = GeneratedField;
5672
5673                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5674                        write!(formatter, "expected one of: {:?}", &FIELDS)
5675                    }
5676
5677                    #[allow(unused_variables)]
5678                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5679                    where
5680                        E: serde::de::Error,
5681                    {
5682                        match value {
5683                            "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
5684                            "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
5685                            "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
5686                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5687                            "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
5688                            "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
5689                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5690                        }
5691                    }
5692                }
5693                deserializer.deserialize_identifier(GeneratedVisitor)
5694            }
5695        }
5696        struct GeneratedVisitor;
5697        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5698            type Value = HopWindowNode;
5699
5700            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5701                formatter.write_str("struct stream_plan.HopWindowNode")
5702            }
5703
5704            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
5705                where
5706                    V: serde::de::MapAccess<'de>,
5707            {
5708                let mut time_col__ = None;
5709                let mut window_slide__ = None;
5710                let mut window_size__ = None;
5711                let mut output_indices__ = None;
5712                let mut window_start_exprs__ = None;
5713                let mut window_end_exprs__ = None;
5714                while let Some(k) = map_.next_key()? {
5715                    match k {
5716                        GeneratedField::TimeCol => {
5717                            if time_col__.is_some() {
5718                                return Err(serde::de::Error::duplicate_field("timeCol"));
5719                            }
5720                            time_col__ = 
5721                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5722                            ;
5723                        }
5724                        GeneratedField::WindowSlide => {
5725                            if window_slide__.is_some() {
5726                                return Err(serde::de::Error::duplicate_field("windowSlide"));
5727                            }
5728                            window_slide__ = map_.next_value()?;
5729                        }
5730                        GeneratedField::WindowSize => {
5731                            if window_size__.is_some() {
5732                                return Err(serde::de::Error::duplicate_field("windowSize"));
5733                            }
5734                            window_size__ = map_.next_value()?;
5735                        }
5736                        GeneratedField::OutputIndices => {
5737                            if output_indices__.is_some() {
5738                                return Err(serde::de::Error::duplicate_field("outputIndices"));
5739                            }
5740                            output_indices__ = 
5741                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5742                                    .into_iter().map(|x| x.0).collect())
5743                            ;
5744                        }
5745                        GeneratedField::WindowStartExprs => {
5746                            if window_start_exprs__.is_some() {
5747                                return Err(serde::de::Error::duplicate_field("windowStartExprs"));
5748                            }
5749                            window_start_exprs__ = Some(map_.next_value()?);
5750                        }
5751                        GeneratedField::WindowEndExprs => {
5752                            if window_end_exprs__.is_some() {
5753                                return Err(serde::de::Error::duplicate_field("windowEndExprs"));
5754                            }
5755                            window_end_exprs__ = Some(map_.next_value()?);
5756                        }
5757                    }
5758                }
5759                Ok(HopWindowNode {
5760                    time_col: time_col__.unwrap_or_default(),
5761                    window_slide: window_slide__,
5762                    window_size: window_size__,
5763                    output_indices: output_indices__.unwrap_or_default(),
5764                    window_start_exprs: window_start_exprs__.unwrap_or_default(),
5765                    window_end_exprs: window_end_exprs__.unwrap_or_default(),
5766                })
5767            }
5768        }
5769        deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
5770    }
5771}
5772impl serde::Serialize for InequalityPair {
5773    #[allow(deprecated)]
5774    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5775    where
5776        S: serde::Serializer,
5777    {
5778        use serde::ser::SerializeStruct;
5779        let mut len = 0;
5780        if self.key_required_larger != 0 {
5781            len += 1;
5782        }
5783        if self.key_required_smaller != 0 {
5784            len += 1;
5785        }
5786        if self.clean_state {
5787            len += 1;
5788        }
5789        if self.delta_expression.is_some() {
5790            len += 1;
5791        }
5792        let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
5793        if self.key_required_larger != 0 {
5794            struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
5795        }
5796        if self.key_required_smaller != 0 {
5797            struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
5798        }
5799        if self.clean_state {
5800            struct_ser.serialize_field("cleanState", &self.clean_state)?;
5801        }
5802        if let Some(v) = self.delta_expression.as_ref() {
5803            struct_ser.serialize_field("deltaExpression", v)?;
5804        }
5805        struct_ser.end()
5806    }
5807}
5808impl<'de> serde::Deserialize<'de> for InequalityPair {
5809    #[allow(deprecated)]
5810    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5811    where
5812        D: serde::Deserializer<'de>,
5813    {
5814        const FIELDS: &[&str] = &[
5815            "key_required_larger",
5816            "keyRequiredLarger",
5817            "key_required_smaller",
5818            "keyRequiredSmaller",
5819            "clean_state",
5820            "cleanState",
5821            "delta_expression",
5822            "deltaExpression",
5823        ];
5824
5825        #[allow(clippy::enum_variant_names)]
5826        enum GeneratedField {
5827            KeyRequiredLarger,
5828            KeyRequiredSmaller,
5829            CleanState,
5830            DeltaExpression,
5831        }
5832        impl<'de> serde::Deserialize<'de> for GeneratedField {
5833            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5834            where
5835                D: serde::Deserializer<'de>,
5836            {
5837                struct GeneratedVisitor;
5838
5839                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5840                    type Value = GeneratedField;
5841
5842                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5843                        write!(formatter, "expected one of: {:?}", &FIELDS)
5844                    }
5845
5846                    #[allow(unused_variables)]
5847                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5848                    where
5849                        E: serde::de::Error,
5850                    {
5851                        match value {
5852                            "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
5853                            "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
5854                            "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
5855                            "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
5856                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5857                        }
5858                    }
5859                }
5860                deserializer.deserialize_identifier(GeneratedVisitor)
5861            }
5862        }
5863        struct GeneratedVisitor;
5864        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5865            type Value = InequalityPair;
5866
5867            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5868                formatter.write_str("struct stream_plan.InequalityPair")
5869            }
5870
5871            fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
5872                where
5873                    V: serde::de::MapAccess<'de>,
5874            {
5875                let mut key_required_larger__ = None;
5876                let mut key_required_smaller__ = None;
5877                let mut clean_state__ = None;
5878                let mut delta_expression__ = None;
5879                while let Some(k) = map_.next_key()? {
5880                    match k {
5881                        GeneratedField::KeyRequiredLarger => {
5882                            if key_required_larger__.is_some() {
5883                                return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
5884                            }
5885                            key_required_larger__ = 
5886                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5887                            ;
5888                        }
5889                        GeneratedField::KeyRequiredSmaller => {
5890                            if key_required_smaller__.is_some() {
5891                                return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
5892                            }
5893                            key_required_smaller__ = 
5894                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5895                            ;
5896                        }
5897                        GeneratedField::CleanState => {
5898                            if clean_state__.is_some() {
5899                                return Err(serde::de::Error::duplicate_field("cleanState"));
5900                            }
5901                            clean_state__ = Some(map_.next_value()?);
5902                        }
5903                        GeneratedField::DeltaExpression => {
5904                            if delta_expression__.is_some() {
5905                                return Err(serde::de::Error::duplicate_field("deltaExpression"));
5906                            }
5907                            delta_expression__ = map_.next_value()?;
5908                        }
5909                    }
5910                }
5911                Ok(InequalityPair {
5912                    key_required_larger: key_required_larger__.unwrap_or_default(),
5913                    key_required_smaller: key_required_smaller__.unwrap_or_default(),
5914                    clean_state: clean_state__.unwrap_or_default(),
5915                    delta_expression: delta_expression__,
5916                })
5917            }
5918        }
5919        deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
5920    }
5921}
5922impl serde::Serialize for JoinEncodingType {
5923    #[allow(deprecated)]
5924    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5925    where
5926        S: serde::Serializer,
5927    {
5928        let variant = match self {
5929            Self::Unspecified => "UNSPECIFIED",
5930            Self::MemoryOptimized => "MEMORY_OPTIMIZED",
5931            Self::CpuOptimized => "CPU_OPTIMIZED",
5932        };
5933        serializer.serialize_str(variant)
5934    }
5935}
5936impl<'de> serde::Deserialize<'de> for JoinEncodingType {
5937    #[allow(deprecated)]
5938    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5939    where
5940        D: serde::Deserializer<'de>,
5941    {
5942        const FIELDS: &[&str] = &[
5943            "UNSPECIFIED",
5944            "MEMORY_OPTIMIZED",
5945            "CPU_OPTIMIZED",
5946        ];
5947
5948        struct GeneratedVisitor;
5949
5950        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5951            type Value = JoinEncodingType;
5952
5953            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5954                write!(formatter, "expected one of: {:?}", &FIELDS)
5955            }
5956
5957            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
5958            where
5959                E: serde::de::Error,
5960            {
5961                i32::try_from(v)
5962                    .ok()
5963                    .and_then(|x| x.try_into().ok())
5964                    .ok_or_else(|| {
5965                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
5966                    })
5967            }
5968
5969            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
5970            where
5971                E: serde::de::Error,
5972            {
5973                i32::try_from(v)
5974                    .ok()
5975                    .and_then(|x| x.try_into().ok())
5976                    .ok_or_else(|| {
5977                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
5978                    })
5979            }
5980
5981            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
5982            where
5983                E: serde::de::Error,
5984            {
5985                match value {
5986                    "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
5987                    "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
5988                    "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
5989                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
5990                }
5991            }
5992        }
5993        deserializer.deserialize_any(GeneratedVisitor)
5994    }
5995}
5996impl serde::Serialize for LocalApproxPercentileNode {
5997    #[allow(deprecated)]
5998    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5999    where
6000        S: serde::Serializer,
6001    {
6002        use serde::ser::SerializeStruct;
6003        let mut len = 0;
6004        if self.base != 0. {
6005            len += 1;
6006        }
6007        if self.percentile_index != 0 {
6008            len += 1;
6009        }
6010        let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
6011        if self.base != 0. {
6012            struct_ser.serialize_field("base", &self.base)?;
6013        }
6014        if self.percentile_index != 0 {
6015            struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
6016        }
6017        struct_ser.end()
6018    }
6019}
6020impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
6021    #[allow(deprecated)]
6022    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6023    where
6024        D: serde::Deserializer<'de>,
6025    {
6026        const FIELDS: &[&str] = &[
6027            "base",
6028            "percentile_index",
6029            "percentileIndex",
6030        ];
6031
6032        #[allow(clippy::enum_variant_names)]
6033        enum GeneratedField {
6034            Base,
6035            PercentileIndex,
6036        }
6037        impl<'de> serde::Deserialize<'de> for GeneratedField {
6038            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6039            where
6040                D: serde::Deserializer<'de>,
6041            {
6042                struct GeneratedVisitor;
6043
6044                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6045                    type Value = GeneratedField;
6046
6047                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6048                        write!(formatter, "expected one of: {:?}", &FIELDS)
6049                    }
6050
6051                    #[allow(unused_variables)]
6052                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6053                    where
6054                        E: serde::de::Error,
6055                    {
6056                        match value {
6057                            "base" => Ok(GeneratedField::Base),
6058                            "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
6059                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6060                        }
6061                    }
6062                }
6063                deserializer.deserialize_identifier(GeneratedVisitor)
6064            }
6065        }
6066        struct GeneratedVisitor;
6067        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6068            type Value = LocalApproxPercentileNode;
6069
6070            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6071                formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
6072            }
6073
6074            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
6075                where
6076                    V: serde::de::MapAccess<'de>,
6077            {
6078                let mut base__ = None;
6079                let mut percentile_index__ = None;
6080                while let Some(k) = map_.next_key()? {
6081                    match k {
6082                        GeneratedField::Base => {
6083                            if base__.is_some() {
6084                                return Err(serde::de::Error::duplicate_field("base"));
6085                            }
6086                            base__ = 
6087                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6088                            ;
6089                        }
6090                        GeneratedField::PercentileIndex => {
6091                            if percentile_index__.is_some() {
6092                                return Err(serde::de::Error::duplicate_field("percentileIndex"));
6093                            }
6094                            percentile_index__ = 
6095                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6096                            ;
6097                        }
6098                    }
6099                }
6100                Ok(LocalApproxPercentileNode {
6101                    base: base__.unwrap_or_default(),
6102                    percentile_index: percentile_index__.unwrap_or_default(),
6103                })
6104            }
6105        }
6106        deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
6107    }
6108}
6109impl serde::Serialize for LookupNode {
6110    #[allow(deprecated)]
6111    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6112    where
6113        S: serde::Serializer,
6114    {
6115        use serde::ser::SerializeStruct;
6116        let mut len = 0;
6117        if !self.arrange_key.is_empty() {
6118            len += 1;
6119        }
6120        if !self.stream_key.is_empty() {
6121            len += 1;
6122        }
6123        if self.use_current_epoch {
6124            len += 1;
6125        }
6126        if !self.column_mapping.is_empty() {
6127            len += 1;
6128        }
6129        if self.arrangement_table_info.is_some() {
6130            len += 1;
6131        }
6132        if self.arrangement_table_id.is_some() {
6133            len += 1;
6134        }
6135        let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
6136        if !self.arrange_key.is_empty() {
6137            struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
6138        }
6139        if !self.stream_key.is_empty() {
6140            struct_ser.serialize_field("streamKey", &self.stream_key)?;
6141        }
6142        if self.use_current_epoch {
6143            struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
6144        }
6145        if !self.column_mapping.is_empty() {
6146            struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
6147        }
6148        if let Some(v) = self.arrangement_table_info.as_ref() {
6149            struct_ser.serialize_field("arrangementTableInfo", v)?;
6150        }
6151        if let Some(v) = self.arrangement_table_id.as_ref() {
6152            match v {
6153                lookup_node::ArrangementTableId::TableId(v) => {
6154                    struct_ser.serialize_field("tableId", v)?;
6155                }
6156                lookup_node::ArrangementTableId::IndexId(v) => {
6157                    struct_ser.serialize_field("indexId", v)?;
6158                }
6159            }
6160        }
6161        struct_ser.end()
6162    }
6163}
6164impl<'de> serde::Deserialize<'de> for LookupNode {
6165    #[allow(deprecated)]
6166    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6167    where
6168        D: serde::Deserializer<'de>,
6169    {
6170        const FIELDS: &[&str] = &[
6171            "arrange_key",
6172            "arrangeKey",
6173            "stream_key",
6174            "streamKey",
6175            "use_current_epoch",
6176            "useCurrentEpoch",
6177            "column_mapping",
6178            "columnMapping",
6179            "arrangement_table_info",
6180            "arrangementTableInfo",
6181            "table_id",
6182            "tableId",
6183            "index_id",
6184            "indexId",
6185        ];
6186
6187        #[allow(clippy::enum_variant_names)]
6188        enum GeneratedField {
6189            ArrangeKey,
6190            StreamKey,
6191            UseCurrentEpoch,
6192            ColumnMapping,
6193            ArrangementTableInfo,
6194            TableId,
6195            IndexId,
6196        }
6197        impl<'de> serde::Deserialize<'de> for GeneratedField {
6198            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6199            where
6200                D: serde::Deserializer<'de>,
6201            {
6202                struct GeneratedVisitor;
6203
6204                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6205                    type Value = GeneratedField;
6206
6207                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6208                        write!(formatter, "expected one of: {:?}", &FIELDS)
6209                    }
6210
6211                    #[allow(unused_variables)]
6212                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6213                    where
6214                        E: serde::de::Error,
6215                    {
6216                        match value {
6217                            "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
6218                            "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
6219                            "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
6220                            "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
6221                            "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
6222                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
6223                            "indexId" | "index_id" => Ok(GeneratedField::IndexId),
6224                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6225                        }
6226                    }
6227                }
6228                deserializer.deserialize_identifier(GeneratedVisitor)
6229            }
6230        }
6231        struct GeneratedVisitor;
6232        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6233            type Value = LookupNode;
6234
6235            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6236                formatter.write_str("struct stream_plan.LookupNode")
6237            }
6238
6239            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
6240                where
6241                    V: serde::de::MapAccess<'de>,
6242            {
6243                let mut arrange_key__ = None;
6244                let mut stream_key__ = None;
6245                let mut use_current_epoch__ = None;
6246                let mut column_mapping__ = None;
6247                let mut arrangement_table_info__ = None;
6248                let mut arrangement_table_id__ = None;
6249                while let Some(k) = map_.next_key()? {
6250                    match k {
6251                        GeneratedField::ArrangeKey => {
6252                            if arrange_key__.is_some() {
6253                                return Err(serde::de::Error::duplicate_field("arrangeKey"));
6254                            }
6255                            arrange_key__ = 
6256                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6257                                    .into_iter().map(|x| x.0).collect())
6258                            ;
6259                        }
6260                        GeneratedField::StreamKey => {
6261                            if stream_key__.is_some() {
6262                                return Err(serde::de::Error::duplicate_field("streamKey"));
6263                            }
6264                            stream_key__ = 
6265                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6266                                    .into_iter().map(|x| x.0).collect())
6267                            ;
6268                        }
6269                        GeneratedField::UseCurrentEpoch => {
6270                            if use_current_epoch__.is_some() {
6271                                return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
6272                            }
6273                            use_current_epoch__ = Some(map_.next_value()?);
6274                        }
6275                        GeneratedField::ColumnMapping => {
6276                            if column_mapping__.is_some() {
6277                                return Err(serde::de::Error::duplicate_field("columnMapping"));
6278                            }
6279                            column_mapping__ = 
6280                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6281                                    .into_iter().map(|x| x.0).collect())
6282                            ;
6283                        }
6284                        GeneratedField::ArrangementTableInfo => {
6285                            if arrangement_table_info__.is_some() {
6286                                return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
6287                            }
6288                            arrangement_table_info__ = map_.next_value()?;
6289                        }
6290                        GeneratedField::TableId => {
6291                            if arrangement_table_id__.is_some() {
6292                                return Err(serde::de::Error::duplicate_field("tableId"));
6293                            }
6294                            arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
6295                        }
6296                        GeneratedField::IndexId => {
6297                            if arrangement_table_id__.is_some() {
6298                                return Err(serde::de::Error::duplicate_field("indexId"));
6299                            }
6300                            arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
6301                        }
6302                    }
6303                }
6304                Ok(LookupNode {
6305                    arrange_key: arrange_key__.unwrap_or_default(),
6306                    stream_key: stream_key__.unwrap_or_default(),
6307                    use_current_epoch: use_current_epoch__.unwrap_or_default(),
6308                    column_mapping: column_mapping__.unwrap_or_default(),
6309                    arrangement_table_info: arrangement_table_info__,
6310                    arrangement_table_id: arrangement_table_id__,
6311                })
6312            }
6313        }
6314        deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
6315    }
6316}
6317impl serde::Serialize for LookupUnionNode {
6318    #[allow(deprecated)]
6319    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6320    where
6321        S: serde::Serializer,
6322    {
6323        use serde::ser::SerializeStruct;
6324        let mut len = 0;
6325        if !self.order.is_empty() {
6326            len += 1;
6327        }
6328        let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
6329        if !self.order.is_empty() {
6330            struct_ser.serialize_field("order", &self.order)?;
6331        }
6332        struct_ser.end()
6333    }
6334}
6335impl<'de> serde::Deserialize<'de> for LookupUnionNode {
6336    #[allow(deprecated)]
6337    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6338    where
6339        D: serde::Deserializer<'de>,
6340    {
6341        const FIELDS: &[&str] = &[
6342            "order",
6343        ];
6344
6345        #[allow(clippy::enum_variant_names)]
6346        enum GeneratedField {
6347            Order,
6348        }
6349        impl<'de> serde::Deserialize<'de> for GeneratedField {
6350            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6351            where
6352                D: serde::Deserializer<'de>,
6353            {
6354                struct GeneratedVisitor;
6355
6356                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6357                    type Value = GeneratedField;
6358
6359                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6360                        write!(formatter, "expected one of: {:?}", &FIELDS)
6361                    }
6362
6363                    #[allow(unused_variables)]
6364                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6365                    where
6366                        E: serde::de::Error,
6367                    {
6368                        match value {
6369                            "order" => Ok(GeneratedField::Order),
6370                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6371                        }
6372                    }
6373                }
6374                deserializer.deserialize_identifier(GeneratedVisitor)
6375            }
6376        }
6377        struct GeneratedVisitor;
6378        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6379            type Value = LookupUnionNode;
6380
6381            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6382                formatter.write_str("struct stream_plan.LookupUnionNode")
6383            }
6384
6385            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
6386                where
6387                    V: serde::de::MapAccess<'de>,
6388            {
6389                let mut order__ = None;
6390                while let Some(k) = map_.next_key()? {
6391                    match k {
6392                        GeneratedField::Order => {
6393                            if order__.is_some() {
6394                                return Err(serde::de::Error::duplicate_field("order"));
6395                            }
6396                            order__ = 
6397                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6398                                    .into_iter().map(|x| x.0).collect())
6399                            ;
6400                        }
6401                    }
6402                }
6403                Ok(LookupUnionNode {
6404                    order: order__.unwrap_or_default(),
6405                })
6406            }
6407        }
6408        deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
6409    }
6410}
6411impl serde::Serialize for MaterializeNode {
6412    #[allow(deprecated)]
6413    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6414    where
6415        S: serde::Serializer,
6416    {
6417        use serde::ser::SerializeStruct;
6418        let mut len = 0;
6419        if self.table_id != 0 {
6420            len += 1;
6421        }
6422        if !self.column_orders.is_empty() {
6423            len += 1;
6424        }
6425        if self.table.is_some() {
6426            len += 1;
6427        }
6428        let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
6429        if self.table_id != 0 {
6430            struct_ser.serialize_field("tableId", &self.table_id)?;
6431        }
6432        if !self.column_orders.is_empty() {
6433            struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6434        }
6435        if let Some(v) = self.table.as_ref() {
6436            struct_ser.serialize_field("table", v)?;
6437        }
6438        struct_ser.end()
6439    }
6440}
6441impl<'de> serde::Deserialize<'de> for MaterializeNode {
6442    #[allow(deprecated)]
6443    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6444    where
6445        D: serde::Deserializer<'de>,
6446    {
6447        const FIELDS: &[&str] = &[
6448            "table_id",
6449            "tableId",
6450            "column_orders",
6451            "columnOrders",
6452            "table",
6453        ];
6454
6455        #[allow(clippy::enum_variant_names)]
6456        enum GeneratedField {
6457            TableId,
6458            ColumnOrders,
6459            Table,
6460        }
6461        impl<'de> serde::Deserialize<'de> for GeneratedField {
6462            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6463            where
6464                D: serde::Deserializer<'de>,
6465            {
6466                struct GeneratedVisitor;
6467
6468                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6469                    type Value = GeneratedField;
6470
6471                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6472                        write!(formatter, "expected one of: {:?}", &FIELDS)
6473                    }
6474
6475                    #[allow(unused_variables)]
6476                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6477                    where
6478                        E: serde::de::Error,
6479                    {
6480                        match value {
6481                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
6482                            "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6483                            "table" => Ok(GeneratedField::Table),
6484                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6485                        }
6486                    }
6487                }
6488                deserializer.deserialize_identifier(GeneratedVisitor)
6489            }
6490        }
6491        struct GeneratedVisitor;
6492        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6493            type Value = MaterializeNode;
6494
6495            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6496                formatter.write_str("struct stream_plan.MaterializeNode")
6497            }
6498
6499            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
6500                where
6501                    V: serde::de::MapAccess<'de>,
6502            {
6503                let mut table_id__ = None;
6504                let mut column_orders__ = None;
6505                let mut table__ = None;
6506                while let Some(k) = map_.next_key()? {
6507                    match k {
6508                        GeneratedField::TableId => {
6509                            if table_id__.is_some() {
6510                                return Err(serde::de::Error::duplicate_field("tableId"));
6511                            }
6512                            table_id__ = 
6513                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6514                            ;
6515                        }
6516                        GeneratedField::ColumnOrders => {
6517                            if column_orders__.is_some() {
6518                                return Err(serde::de::Error::duplicate_field("columnOrders"));
6519                            }
6520                            column_orders__ = Some(map_.next_value()?);
6521                        }
6522                        GeneratedField::Table => {
6523                            if table__.is_some() {
6524                                return Err(serde::de::Error::duplicate_field("table"));
6525                            }
6526                            table__ = map_.next_value()?;
6527                        }
6528                    }
6529                }
6530                Ok(MaterializeNode {
6531                    table_id: table_id__.unwrap_or_default(),
6532                    column_orders: column_orders__.unwrap_or_default(),
6533                    table: table__,
6534                })
6535            }
6536        }
6537        deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
6538    }
6539}
6540impl serde::Serialize for MaterializedExprsNode {
6541    #[allow(deprecated)]
6542    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6543    where
6544        S: serde::Serializer,
6545    {
6546        use serde::ser::SerializeStruct;
6547        let mut len = 0;
6548        if !self.exprs.is_empty() {
6549            len += 1;
6550        }
6551        if self.state_table.is_some() {
6552            len += 1;
6553        }
6554        if self.state_clean_col_idx.is_some() {
6555            len += 1;
6556        }
6557        let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
6558        if !self.exprs.is_empty() {
6559            struct_ser.serialize_field("exprs", &self.exprs)?;
6560        }
6561        if let Some(v) = self.state_table.as_ref() {
6562            struct_ser.serialize_field("stateTable", v)?;
6563        }
6564        if let Some(v) = self.state_clean_col_idx.as_ref() {
6565            struct_ser.serialize_field("stateCleanColIdx", v)?;
6566        }
6567        struct_ser.end()
6568    }
6569}
6570impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
6571    #[allow(deprecated)]
6572    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6573    where
6574        D: serde::Deserializer<'de>,
6575    {
6576        const FIELDS: &[&str] = &[
6577            "exprs",
6578            "state_table",
6579            "stateTable",
6580            "state_clean_col_idx",
6581            "stateCleanColIdx",
6582        ];
6583
6584        #[allow(clippy::enum_variant_names)]
6585        enum GeneratedField {
6586            Exprs,
6587            StateTable,
6588            StateCleanColIdx,
6589        }
6590        impl<'de> serde::Deserialize<'de> for GeneratedField {
6591            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6592            where
6593                D: serde::Deserializer<'de>,
6594            {
6595                struct GeneratedVisitor;
6596
6597                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6598                    type Value = GeneratedField;
6599
6600                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6601                        write!(formatter, "expected one of: {:?}", &FIELDS)
6602                    }
6603
6604                    #[allow(unused_variables)]
6605                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6606                    where
6607                        E: serde::de::Error,
6608                    {
6609                        match value {
6610                            "exprs" => Ok(GeneratedField::Exprs),
6611                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
6612                            "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
6613                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6614                        }
6615                    }
6616                }
6617                deserializer.deserialize_identifier(GeneratedVisitor)
6618            }
6619        }
6620        struct GeneratedVisitor;
6621        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6622            type Value = MaterializedExprsNode;
6623
6624            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6625                formatter.write_str("struct stream_plan.MaterializedExprsNode")
6626            }
6627
6628            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
6629                where
6630                    V: serde::de::MapAccess<'de>,
6631            {
6632                let mut exprs__ = None;
6633                let mut state_table__ = None;
6634                let mut state_clean_col_idx__ = None;
6635                while let Some(k) = map_.next_key()? {
6636                    match k {
6637                        GeneratedField::Exprs => {
6638                            if exprs__.is_some() {
6639                                return Err(serde::de::Error::duplicate_field("exprs"));
6640                            }
6641                            exprs__ = Some(map_.next_value()?);
6642                        }
6643                        GeneratedField::StateTable => {
6644                            if state_table__.is_some() {
6645                                return Err(serde::de::Error::duplicate_field("stateTable"));
6646                            }
6647                            state_table__ = map_.next_value()?;
6648                        }
6649                        GeneratedField::StateCleanColIdx => {
6650                            if state_clean_col_idx__.is_some() {
6651                                return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
6652                            }
6653                            state_clean_col_idx__ = 
6654                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6655                            ;
6656                        }
6657                    }
6658                }
6659                Ok(MaterializedExprsNode {
6660                    exprs: exprs__.unwrap_or_default(),
6661                    state_table: state_table__,
6662                    state_clean_col_idx: state_clean_col_idx__,
6663                })
6664            }
6665        }
6666        deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
6667    }
6668}
6669impl serde::Serialize for MergeNode {
6670    #[allow(deprecated)]
6671    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6672    where
6673        S: serde::Serializer,
6674    {
6675        use serde::ser::SerializeStruct;
6676        let mut len = 0;
6677        if !self.upstream_actor_id.is_empty() {
6678            len += 1;
6679        }
6680        if self.upstream_fragment_id != 0 {
6681            len += 1;
6682        }
6683        if self.upstream_dispatcher_type != 0 {
6684            len += 1;
6685        }
6686        if !self.fields.is_empty() {
6687            len += 1;
6688        }
6689        let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
6690        if !self.upstream_actor_id.is_empty() {
6691            struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
6692        }
6693        if self.upstream_fragment_id != 0 {
6694            struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
6695        }
6696        if self.upstream_dispatcher_type != 0 {
6697            let v = DispatcherType::try_from(self.upstream_dispatcher_type)
6698                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
6699            struct_ser.serialize_field("upstreamDispatcherType", &v)?;
6700        }
6701        if !self.fields.is_empty() {
6702            struct_ser.serialize_field("fields", &self.fields)?;
6703        }
6704        struct_ser.end()
6705    }
6706}
6707impl<'de> serde::Deserialize<'de> for MergeNode {
6708    #[allow(deprecated)]
6709    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6710    where
6711        D: serde::Deserializer<'de>,
6712    {
6713        const FIELDS: &[&str] = &[
6714            "upstream_actor_id",
6715            "upstreamActorId",
6716            "upstream_fragment_id",
6717            "upstreamFragmentId",
6718            "upstream_dispatcher_type",
6719            "upstreamDispatcherType",
6720            "fields",
6721        ];
6722
6723        #[allow(clippy::enum_variant_names)]
6724        enum GeneratedField {
6725            UpstreamActorId,
6726            UpstreamFragmentId,
6727            UpstreamDispatcherType,
6728            Fields,
6729        }
6730        impl<'de> serde::Deserialize<'de> for GeneratedField {
6731            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6732            where
6733                D: serde::Deserializer<'de>,
6734            {
6735                struct GeneratedVisitor;
6736
6737                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6738                    type Value = GeneratedField;
6739
6740                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6741                        write!(formatter, "expected one of: {:?}", &FIELDS)
6742                    }
6743
6744                    #[allow(unused_variables)]
6745                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6746                    where
6747                        E: serde::de::Error,
6748                    {
6749                        match value {
6750                            "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
6751                            "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
6752                            "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
6753                            "fields" => Ok(GeneratedField::Fields),
6754                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6755                        }
6756                    }
6757                }
6758                deserializer.deserialize_identifier(GeneratedVisitor)
6759            }
6760        }
6761        struct GeneratedVisitor;
6762        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6763            type Value = MergeNode;
6764
6765            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6766                formatter.write_str("struct stream_plan.MergeNode")
6767            }
6768
6769            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
6770                where
6771                    V: serde::de::MapAccess<'de>,
6772            {
6773                let mut upstream_actor_id__ = None;
6774                let mut upstream_fragment_id__ = None;
6775                let mut upstream_dispatcher_type__ = None;
6776                let mut fields__ = None;
6777                while let Some(k) = map_.next_key()? {
6778                    match k {
6779                        GeneratedField::UpstreamActorId => {
6780                            if upstream_actor_id__.is_some() {
6781                                return Err(serde::de::Error::duplicate_field("upstreamActorId"));
6782                            }
6783                            upstream_actor_id__ = 
6784                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6785                                    .into_iter().map(|x| x.0).collect())
6786                            ;
6787                        }
6788                        GeneratedField::UpstreamFragmentId => {
6789                            if upstream_fragment_id__.is_some() {
6790                                return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
6791                            }
6792                            upstream_fragment_id__ = 
6793                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6794                            ;
6795                        }
6796                        GeneratedField::UpstreamDispatcherType => {
6797                            if upstream_dispatcher_type__.is_some() {
6798                                return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
6799                            }
6800                            upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
6801                        }
6802                        GeneratedField::Fields => {
6803                            if fields__.is_some() {
6804                                return Err(serde::de::Error::duplicate_field("fields"));
6805                            }
6806                            fields__ = Some(map_.next_value()?);
6807                        }
6808                    }
6809                }
6810                Ok(MergeNode {
6811                    upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
6812                    upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
6813                    upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
6814                    fields: fields__.unwrap_or_default(),
6815                })
6816            }
6817        }
6818        deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
6819    }
6820}
6821impl serde::Serialize for NoOpNode {
6822    #[allow(deprecated)]
6823    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6824    where
6825        S: serde::Serializer,
6826    {
6827        use serde::ser::SerializeStruct;
6828        let len = 0;
6829        let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
6830        struct_ser.end()
6831    }
6832}
6833impl<'de> serde::Deserialize<'de> for NoOpNode {
6834    #[allow(deprecated)]
6835    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6836    where
6837        D: serde::Deserializer<'de>,
6838    {
6839        const FIELDS: &[&str] = &[
6840        ];
6841
6842        #[allow(clippy::enum_variant_names)]
6843        enum GeneratedField {
6844        }
6845        impl<'de> serde::Deserialize<'de> for GeneratedField {
6846            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6847            where
6848                D: serde::Deserializer<'de>,
6849            {
6850                struct GeneratedVisitor;
6851
6852                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6853                    type Value = GeneratedField;
6854
6855                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6856                        write!(formatter, "expected one of: {:?}", &FIELDS)
6857                    }
6858
6859                    #[allow(unused_variables)]
6860                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6861                    where
6862                        E: serde::de::Error,
6863                    {
6864                            Err(serde::de::Error::unknown_field(value, FIELDS))
6865                    }
6866                }
6867                deserializer.deserialize_identifier(GeneratedVisitor)
6868            }
6869        }
6870        struct GeneratedVisitor;
6871        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6872            type Value = NoOpNode;
6873
6874            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6875                formatter.write_str("struct stream_plan.NoOpNode")
6876            }
6877
6878            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
6879                where
6880                    V: serde::de::MapAccess<'de>,
6881            {
6882                while map_.next_key::<GeneratedField>()?.is_some() {
6883                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6884                }
6885                Ok(NoOpNode {
6886                })
6887            }
6888        }
6889        deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
6890    }
6891}
6892impl serde::Serialize for NowModeGenerateSeries {
6893    #[allow(deprecated)]
6894    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6895    where
6896        S: serde::Serializer,
6897    {
6898        use serde::ser::SerializeStruct;
6899        let mut len = 0;
6900        if self.start_timestamp.is_some() {
6901            len += 1;
6902        }
6903        if self.interval.is_some() {
6904            len += 1;
6905        }
6906        let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
6907        if let Some(v) = self.start_timestamp.as_ref() {
6908            struct_ser.serialize_field("startTimestamp", v)?;
6909        }
6910        if let Some(v) = self.interval.as_ref() {
6911            struct_ser.serialize_field("interval", v)?;
6912        }
6913        struct_ser.end()
6914    }
6915}
6916impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
6917    #[allow(deprecated)]
6918    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6919    where
6920        D: serde::Deserializer<'de>,
6921    {
6922        const FIELDS: &[&str] = &[
6923            "start_timestamp",
6924            "startTimestamp",
6925            "interval",
6926        ];
6927
6928        #[allow(clippy::enum_variant_names)]
6929        enum GeneratedField {
6930            StartTimestamp,
6931            Interval,
6932        }
6933        impl<'de> serde::Deserialize<'de> for GeneratedField {
6934            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6935            where
6936                D: serde::Deserializer<'de>,
6937            {
6938                struct GeneratedVisitor;
6939
6940                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6941                    type Value = GeneratedField;
6942
6943                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6944                        write!(formatter, "expected one of: {:?}", &FIELDS)
6945                    }
6946
6947                    #[allow(unused_variables)]
6948                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6949                    where
6950                        E: serde::de::Error,
6951                    {
6952                        match value {
6953                            "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
6954                            "interval" => Ok(GeneratedField::Interval),
6955                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6956                        }
6957                    }
6958                }
6959                deserializer.deserialize_identifier(GeneratedVisitor)
6960            }
6961        }
6962        struct GeneratedVisitor;
6963        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6964            type Value = NowModeGenerateSeries;
6965
6966            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6967                formatter.write_str("struct stream_plan.NowModeGenerateSeries")
6968            }
6969
6970            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
6971                where
6972                    V: serde::de::MapAccess<'de>,
6973            {
6974                let mut start_timestamp__ = None;
6975                let mut interval__ = None;
6976                while let Some(k) = map_.next_key()? {
6977                    match k {
6978                        GeneratedField::StartTimestamp => {
6979                            if start_timestamp__.is_some() {
6980                                return Err(serde::de::Error::duplicate_field("startTimestamp"));
6981                            }
6982                            start_timestamp__ = map_.next_value()?;
6983                        }
6984                        GeneratedField::Interval => {
6985                            if interval__.is_some() {
6986                                return Err(serde::de::Error::duplicate_field("interval"));
6987                            }
6988                            interval__ = map_.next_value()?;
6989                        }
6990                    }
6991                }
6992                Ok(NowModeGenerateSeries {
6993                    start_timestamp: start_timestamp__,
6994                    interval: interval__,
6995                })
6996            }
6997        }
6998        deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
6999    }
7000}
7001impl serde::Serialize for NowModeUpdateCurrent {
7002    #[allow(deprecated)]
7003    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7004    where
7005        S: serde::Serializer,
7006    {
7007        use serde::ser::SerializeStruct;
7008        let len = 0;
7009        let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
7010        struct_ser.end()
7011    }
7012}
7013impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
7014    #[allow(deprecated)]
7015    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7016    where
7017        D: serde::Deserializer<'de>,
7018    {
7019        const FIELDS: &[&str] = &[
7020        ];
7021
7022        #[allow(clippy::enum_variant_names)]
7023        enum GeneratedField {
7024        }
7025        impl<'de> serde::Deserialize<'de> for GeneratedField {
7026            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7027            where
7028                D: serde::Deserializer<'de>,
7029            {
7030                struct GeneratedVisitor;
7031
7032                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7033                    type Value = GeneratedField;
7034
7035                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7036                        write!(formatter, "expected one of: {:?}", &FIELDS)
7037                    }
7038
7039                    #[allow(unused_variables)]
7040                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7041                    where
7042                        E: serde::de::Error,
7043                    {
7044                            Err(serde::de::Error::unknown_field(value, FIELDS))
7045                    }
7046                }
7047                deserializer.deserialize_identifier(GeneratedVisitor)
7048            }
7049        }
7050        struct GeneratedVisitor;
7051        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7052            type Value = NowModeUpdateCurrent;
7053
7054            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7055                formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
7056            }
7057
7058            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
7059                where
7060                    V: serde::de::MapAccess<'de>,
7061            {
7062                while map_.next_key::<GeneratedField>()?.is_some() {
7063                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7064                }
7065                Ok(NowModeUpdateCurrent {
7066                })
7067            }
7068        }
7069        deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
7070    }
7071}
7072impl serde::Serialize for NowNode {
7073    #[allow(deprecated)]
7074    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7075    where
7076        S: serde::Serializer,
7077    {
7078        use serde::ser::SerializeStruct;
7079        let mut len = 0;
7080        if self.state_table.is_some() {
7081            len += 1;
7082        }
7083        if self.mode.is_some() {
7084            len += 1;
7085        }
7086        let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
7087        if let Some(v) = self.state_table.as_ref() {
7088            struct_ser.serialize_field("stateTable", v)?;
7089        }
7090        if let Some(v) = self.mode.as_ref() {
7091            match v {
7092                now_node::Mode::UpdateCurrent(v) => {
7093                    struct_ser.serialize_field("updateCurrent", v)?;
7094                }
7095                now_node::Mode::GenerateSeries(v) => {
7096                    struct_ser.serialize_field("generateSeries", v)?;
7097                }
7098            }
7099        }
7100        struct_ser.end()
7101    }
7102}
7103impl<'de> serde::Deserialize<'de> for NowNode {
7104    #[allow(deprecated)]
7105    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7106    where
7107        D: serde::Deserializer<'de>,
7108    {
7109        const FIELDS: &[&str] = &[
7110            "state_table",
7111            "stateTable",
7112            "update_current",
7113            "updateCurrent",
7114            "generate_series",
7115            "generateSeries",
7116        ];
7117
7118        #[allow(clippy::enum_variant_names)]
7119        enum GeneratedField {
7120            StateTable,
7121            UpdateCurrent,
7122            GenerateSeries,
7123        }
7124        impl<'de> serde::Deserialize<'de> for GeneratedField {
7125            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7126            where
7127                D: serde::Deserializer<'de>,
7128            {
7129                struct GeneratedVisitor;
7130
7131                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7132                    type Value = GeneratedField;
7133
7134                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7135                        write!(formatter, "expected one of: {:?}", &FIELDS)
7136                    }
7137
7138                    #[allow(unused_variables)]
7139                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7140                    where
7141                        E: serde::de::Error,
7142                    {
7143                        match value {
7144                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7145                            "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
7146                            "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
7147                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7148                        }
7149                    }
7150                }
7151                deserializer.deserialize_identifier(GeneratedVisitor)
7152            }
7153        }
7154        struct GeneratedVisitor;
7155        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7156            type Value = NowNode;
7157
7158            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7159                formatter.write_str("struct stream_plan.NowNode")
7160            }
7161
7162            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
7163                where
7164                    V: serde::de::MapAccess<'de>,
7165            {
7166                let mut state_table__ = None;
7167                let mut mode__ = None;
7168                while let Some(k) = map_.next_key()? {
7169                    match k {
7170                        GeneratedField::StateTable => {
7171                            if state_table__.is_some() {
7172                                return Err(serde::de::Error::duplicate_field("stateTable"));
7173                            }
7174                            state_table__ = map_.next_value()?;
7175                        }
7176                        GeneratedField::UpdateCurrent => {
7177                            if mode__.is_some() {
7178                                return Err(serde::de::Error::duplicate_field("updateCurrent"));
7179                            }
7180                            mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
7181;
7182                        }
7183                        GeneratedField::GenerateSeries => {
7184                            if mode__.is_some() {
7185                                return Err(serde::de::Error::duplicate_field("generateSeries"));
7186                            }
7187                            mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
7188;
7189                        }
7190                    }
7191                }
7192                Ok(NowNode {
7193                    state_table: state_table__,
7194                    mode: mode__,
7195                })
7196            }
7197        }
7198        deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
7199    }
7200}
7201impl serde::Serialize for OverWindowCachePolicy {
7202    #[allow(deprecated)]
7203    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7204    where
7205        S: serde::Serializer,
7206    {
7207        let variant = match self {
7208            Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7209            Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
7210            Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
7211            Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7212            Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7213        };
7214        serializer.serialize_str(variant)
7215    }
7216}
7217impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
7218    #[allow(deprecated)]
7219    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7220    where
7221        D: serde::Deserializer<'de>,
7222    {
7223        const FIELDS: &[&str] = &[
7224            "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7225            "OVER_WINDOW_CACHE_POLICY_FULL",
7226            "OVER_WINDOW_CACHE_POLICY_RECENT",
7227            "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7228            "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7229        ];
7230
7231        struct GeneratedVisitor;
7232
7233        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7234            type Value = OverWindowCachePolicy;
7235
7236            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7237                write!(formatter, "expected one of: {:?}", &FIELDS)
7238            }
7239
7240            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7241            where
7242                E: serde::de::Error,
7243            {
7244                i32::try_from(v)
7245                    .ok()
7246                    .and_then(|x| x.try_into().ok())
7247                    .ok_or_else(|| {
7248                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7249                    })
7250            }
7251
7252            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7253            where
7254                E: serde::de::Error,
7255            {
7256                i32::try_from(v)
7257                    .ok()
7258                    .and_then(|x| x.try_into().ok())
7259                    .ok_or_else(|| {
7260                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7261                    })
7262            }
7263
7264            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7265            where
7266                E: serde::de::Error,
7267            {
7268                match value {
7269                    "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
7270                    "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
7271                    "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
7272                    "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
7273                    "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
7274                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7275                }
7276            }
7277        }
7278        deserializer.deserialize_any(GeneratedVisitor)
7279    }
7280}
7281impl serde::Serialize for OverWindowNode {
7282    #[allow(deprecated)]
7283    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7284    where
7285        S: serde::Serializer,
7286    {
7287        use serde::ser::SerializeStruct;
7288        let mut len = 0;
7289        if !self.calls.is_empty() {
7290            len += 1;
7291        }
7292        if !self.partition_by.is_empty() {
7293            len += 1;
7294        }
7295        if !self.order_by.is_empty() {
7296            len += 1;
7297        }
7298        if self.state_table.is_some() {
7299            len += 1;
7300        }
7301        if self.cache_policy != 0 {
7302            len += 1;
7303        }
7304        let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
7305        if !self.calls.is_empty() {
7306            struct_ser.serialize_field("calls", &self.calls)?;
7307        }
7308        if !self.partition_by.is_empty() {
7309            struct_ser.serialize_field("partitionBy", &self.partition_by)?;
7310        }
7311        if !self.order_by.is_empty() {
7312            struct_ser.serialize_field("orderBy", &self.order_by)?;
7313        }
7314        if let Some(v) = self.state_table.as_ref() {
7315            struct_ser.serialize_field("stateTable", v)?;
7316        }
7317        if self.cache_policy != 0 {
7318            let v = OverWindowCachePolicy::try_from(self.cache_policy)
7319                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
7320            struct_ser.serialize_field("cachePolicy", &v)?;
7321        }
7322        struct_ser.end()
7323    }
7324}
7325impl<'de> serde::Deserialize<'de> for OverWindowNode {
7326    #[allow(deprecated)]
7327    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7328    where
7329        D: serde::Deserializer<'de>,
7330    {
7331        const FIELDS: &[&str] = &[
7332            "calls",
7333            "partition_by",
7334            "partitionBy",
7335            "order_by",
7336            "orderBy",
7337            "state_table",
7338            "stateTable",
7339            "cache_policy",
7340            "cachePolicy",
7341        ];
7342
7343        #[allow(clippy::enum_variant_names)]
7344        enum GeneratedField {
7345            Calls,
7346            PartitionBy,
7347            OrderBy,
7348            StateTable,
7349            CachePolicy,
7350        }
7351        impl<'de> serde::Deserialize<'de> for GeneratedField {
7352            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7353            where
7354                D: serde::Deserializer<'de>,
7355            {
7356                struct GeneratedVisitor;
7357
7358                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7359                    type Value = GeneratedField;
7360
7361                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7362                        write!(formatter, "expected one of: {:?}", &FIELDS)
7363                    }
7364
7365                    #[allow(unused_variables)]
7366                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7367                    where
7368                        E: serde::de::Error,
7369                    {
7370                        match value {
7371                            "calls" => Ok(GeneratedField::Calls),
7372                            "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
7373                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
7374                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7375                            "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
7376                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7377                        }
7378                    }
7379                }
7380                deserializer.deserialize_identifier(GeneratedVisitor)
7381            }
7382        }
7383        struct GeneratedVisitor;
7384        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7385            type Value = OverWindowNode;
7386
7387            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7388                formatter.write_str("struct stream_plan.OverWindowNode")
7389            }
7390
7391            fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
7392                where
7393                    V: serde::de::MapAccess<'de>,
7394            {
7395                let mut calls__ = None;
7396                let mut partition_by__ = None;
7397                let mut order_by__ = None;
7398                let mut state_table__ = None;
7399                let mut cache_policy__ = None;
7400                while let Some(k) = map_.next_key()? {
7401                    match k {
7402                        GeneratedField::Calls => {
7403                            if calls__.is_some() {
7404                                return Err(serde::de::Error::duplicate_field("calls"));
7405                            }
7406                            calls__ = Some(map_.next_value()?);
7407                        }
7408                        GeneratedField::PartitionBy => {
7409                            if partition_by__.is_some() {
7410                                return Err(serde::de::Error::duplicate_field("partitionBy"));
7411                            }
7412                            partition_by__ = 
7413                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7414                                    .into_iter().map(|x| x.0).collect())
7415                            ;
7416                        }
7417                        GeneratedField::OrderBy => {
7418                            if order_by__.is_some() {
7419                                return Err(serde::de::Error::duplicate_field("orderBy"));
7420                            }
7421                            order_by__ = Some(map_.next_value()?);
7422                        }
7423                        GeneratedField::StateTable => {
7424                            if state_table__.is_some() {
7425                                return Err(serde::de::Error::duplicate_field("stateTable"));
7426                            }
7427                            state_table__ = map_.next_value()?;
7428                        }
7429                        GeneratedField::CachePolicy => {
7430                            if cache_policy__.is_some() {
7431                                return Err(serde::de::Error::duplicate_field("cachePolicy"));
7432                            }
7433                            cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
7434                        }
7435                    }
7436                }
7437                Ok(OverWindowNode {
7438                    calls: calls__.unwrap_or_default(),
7439                    partition_by: partition_by__.unwrap_or_default(),
7440                    order_by: order_by__.unwrap_or_default(),
7441                    state_table: state_table__,
7442                    cache_policy: cache_policy__.unwrap_or_default(),
7443                })
7444            }
7445        }
7446        deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
7447    }
7448}
7449impl serde::Serialize for PauseMutation {
7450    #[allow(deprecated)]
7451    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7452    where
7453        S: serde::Serializer,
7454    {
7455        use serde::ser::SerializeStruct;
7456        let len = 0;
7457        let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
7458        struct_ser.end()
7459    }
7460}
7461impl<'de> serde::Deserialize<'de> for PauseMutation {
7462    #[allow(deprecated)]
7463    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7464    where
7465        D: serde::Deserializer<'de>,
7466    {
7467        const FIELDS: &[&str] = &[
7468        ];
7469
7470        #[allow(clippy::enum_variant_names)]
7471        enum GeneratedField {
7472        }
7473        impl<'de> serde::Deserialize<'de> for GeneratedField {
7474            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7475            where
7476                D: serde::Deserializer<'de>,
7477            {
7478                struct GeneratedVisitor;
7479
7480                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7481                    type Value = GeneratedField;
7482
7483                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7484                        write!(formatter, "expected one of: {:?}", &FIELDS)
7485                    }
7486
7487                    #[allow(unused_variables)]
7488                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7489                    where
7490                        E: serde::de::Error,
7491                    {
7492                            Err(serde::de::Error::unknown_field(value, FIELDS))
7493                    }
7494                }
7495                deserializer.deserialize_identifier(GeneratedVisitor)
7496            }
7497        }
7498        struct GeneratedVisitor;
7499        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7500            type Value = PauseMutation;
7501
7502            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7503                formatter.write_str("struct stream_plan.PauseMutation")
7504            }
7505
7506            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
7507                where
7508                    V: serde::de::MapAccess<'de>,
7509            {
7510                while map_.next_key::<GeneratedField>()?.is_some() {
7511                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7512                }
7513                Ok(PauseMutation {
7514                })
7515            }
7516        }
7517        deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
7518    }
7519}
7520impl serde::Serialize for ProjectNode {
7521    #[allow(deprecated)]
7522    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7523    where
7524        S: serde::Serializer,
7525    {
7526        use serde::ser::SerializeStruct;
7527        let mut len = 0;
7528        if !self.select_list.is_empty() {
7529            len += 1;
7530        }
7531        if !self.watermark_input_cols.is_empty() {
7532            len += 1;
7533        }
7534        if !self.watermark_output_cols.is_empty() {
7535            len += 1;
7536        }
7537        if !self.nondecreasing_exprs.is_empty() {
7538            len += 1;
7539        }
7540        if self.noop_update_hint {
7541            len += 1;
7542        }
7543        let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
7544        if !self.select_list.is_empty() {
7545            struct_ser.serialize_field("selectList", &self.select_list)?;
7546        }
7547        if !self.watermark_input_cols.is_empty() {
7548            struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
7549        }
7550        if !self.watermark_output_cols.is_empty() {
7551            struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
7552        }
7553        if !self.nondecreasing_exprs.is_empty() {
7554            struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
7555        }
7556        if self.noop_update_hint {
7557            struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
7558        }
7559        struct_ser.end()
7560    }
7561}
7562impl<'de> serde::Deserialize<'de> for ProjectNode {
7563    #[allow(deprecated)]
7564    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7565    where
7566        D: serde::Deserializer<'de>,
7567    {
7568        const FIELDS: &[&str] = &[
7569            "select_list",
7570            "selectList",
7571            "watermark_input_cols",
7572            "watermarkInputCols",
7573            "watermark_output_cols",
7574            "watermarkOutputCols",
7575            "nondecreasing_exprs",
7576            "nondecreasingExprs",
7577            "noop_update_hint",
7578            "noopUpdateHint",
7579        ];
7580
7581        #[allow(clippy::enum_variant_names)]
7582        enum GeneratedField {
7583            SelectList,
7584            WatermarkInputCols,
7585            WatermarkOutputCols,
7586            NondecreasingExprs,
7587            NoopUpdateHint,
7588        }
7589        impl<'de> serde::Deserialize<'de> for GeneratedField {
7590            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7591            where
7592                D: serde::Deserializer<'de>,
7593            {
7594                struct GeneratedVisitor;
7595
7596                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7597                    type Value = GeneratedField;
7598
7599                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7600                        write!(formatter, "expected one of: {:?}", &FIELDS)
7601                    }
7602
7603                    #[allow(unused_variables)]
7604                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7605                    where
7606                        E: serde::de::Error,
7607                    {
7608                        match value {
7609                            "selectList" | "select_list" => Ok(GeneratedField::SelectList),
7610                            "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
7611                            "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
7612                            "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
7613                            "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
7614                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7615                        }
7616                    }
7617                }
7618                deserializer.deserialize_identifier(GeneratedVisitor)
7619            }
7620        }
7621        struct GeneratedVisitor;
7622        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7623            type Value = ProjectNode;
7624
7625            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7626                formatter.write_str("struct stream_plan.ProjectNode")
7627            }
7628
7629            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
7630                where
7631                    V: serde::de::MapAccess<'de>,
7632            {
7633                let mut select_list__ = None;
7634                let mut watermark_input_cols__ = None;
7635                let mut watermark_output_cols__ = None;
7636                let mut nondecreasing_exprs__ = None;
7637                let mut noop_update_hint__ = None;
7638                while let Some(k) = map_.next_key()? {
7639                    match k {
7640                        GeneratedField::SelectList => {
7641                            if select_list__.is_some() {
7642                                return Err(serde::de::Error::duplicate_field("selectList"));
7643                            }
7644                            select_list__ = Some(map_.next_value()?);
7645                        }
7646                        GeneratedField::WatermarkInputCols => {
7647                            if watermark_input_cols__.is_some() {
7648                                return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
7649                            }
7650                            watermark_input_cols__ = 
7651                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7652                                    .into_iter().map(|x| x.0).collect())
7653                            ;
7654                        }
7655                        GeneratedField::WatermarkOutputCols => {
7656                            if watermark_output_cols__.is_some() {
7657                                return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
7658                            }
7659                            watermark_output_cols__ = 
7660                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7661                                    .into_iter().map(|x| x.0).collect())
7662                            ;
7663                        }
7664                        GeneratedField::NondecreasingExprs => {
7665                            if nondecreasing_exprs__.is_some() {
7666                                return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
7667                            }
7668                            nondecreasing_exprs__ = 
7669                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7670                                    .into_iter().map(|x| x.0).collect())
7671                            ;
7672                        }
7673                        GeneratedField::NoopUpdateHint => {
7674                            if noop_update_hint__.is_some() {
7675                                return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
7676                            }
7677                            noop_update_hint__ = Some(map_.next_value()?);
7678                        }
7679                    }
7680                }
7681                Ok(ProjectNode {
7682                    select_list: select_list__.unwrap_or_default(),
7683                    watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
7684                    watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
7685                    nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
7686                    noop_update_hint: noop_update_hint__.unwrap_or_default(),
7687                })
7688            }
7689        }
7690        deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
7691    }
7692}
7693impl serde::Serialize for ProjectSetNode {
7694    #[allow(deprecated)]
7695    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7696    where
7697        S: serde::Serializer,
7698    {
7699        use serde::ser::SerializeStruct;
7700        let mut len = 0;
7701        if !self.select_list.is_empty() {
7702            len += 1;
7703        }
7704        if !self.watermark_input_cols.is_empty() {
7705            len += 1;
7706        }
7707        if !self.watermark_expr_indices.is_empty() {
7708            len += 1;
7709        }
7710        if !self.nondecreasing_exprs.is_empty() {
7711            len += 1;
7712        }
7713        let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
7714        if !self.select_list.is_empty() {
7715            struct_ser.serialize_field("selectList", &self.select_list)?;
7716        }
7717        if !self.watermark_input_cols.is_empty() {
7718            struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
7719        }
7720        if !self.watermark_expr_indices.is_empty() {
7721            struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
7722        }
7723        if !self.nondecreasing_exprs.is_empty() {
7724            struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
7725        }
7726        struct_ser.end()
7727    }
7728}
7729impl<'de> serde::Deserialize<'de> for ProjectSetNode {
7730    #[allow(deprecated)]
7731    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7732    where
7733        D: serde::Deserializer<'de>,
7734    {
7735        const FIELDS: &[&str] = &[
7736            "select_list",
7737            "selectList",
7738            "watermark_input_cols",
7739            "watermarkInputCols",
7740            "watermark_expr_indices",
7741            "watermarkExprIndices",
7742            "nondecreasing_exprs",
7743            "nondecreasingExprs",
7744        ];
7745
7746        #[allow(clippy::enum_variant_names)]
7747        enum GeneratedField {
7748            SelectList,
7749            WatermarkInputCols,
7750            WatermarkExprIndices,
7751            NondecreasingExprs,
7752        }
7753        impl<'de> serde::Deserialize<'de> for GeneratedField {
7754            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7755            where
7756                D: serde::Deserializer<'de>,
7757            {
7758                struct GeneratedVisitor;
7759
7760                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7761                    type Value = GeneratedField;
7762
7763                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7764                        write!(formatter, "expected one of: {:?}", &FIELDS)
7765                    }
7766
7767                    #[allow(unused_variables)]
7768                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7769                    where
7770                        E: serde::de::Error,
7771                    {
7772                        match value {
7773                            "selectList" | "select_list" => Ok(GeneratedField::SelectList),
7774                            "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
7775                            "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
7776                            "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
7777                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7778                        }
7779                    }
7780                }
7781                deserializer.deserialize_identifier(GeneratedVisitor)
7782            }
7783        }
7784        struct GeneratedVisitor;
7785        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7786            type Value = ProjectSetNode;
7787
7788            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7789                formatter.write_str("struct stream_plan.ProjectSetNode")
7790            }
7791
7792            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
7793                where
7794                    V: serde::de::MapAccess<'de>,
7795            {
7796                let mut select_list__ = None;
7797                let mut watermark_input_cols__ = None;
7798                let mut watermark_expr_indices__ = None;
7799                let mut nondecreasing_exprs__ = None;
7800                while let Some(k) = map_.next_key()? {
7801                    match k {
7802                        GeneratedField::SelectList => {
7803                            if select_list__.is_some() {
7804                                return Err(serde::de::Error::duplicate_field("selectList"));
7805                            }
7806                            select_list__ = Some(map_.next_value()?);
7807                        }
7808                        GeneratedField::WatermarkInputCols => {
7809                            if watermark_input_cols__.is_some() {
7810                                return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
7811                            }
7812                            watermark_input_cols__ = 
7813                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7814                                    .into_iter().map(|x| x.0).collect())
7815                            ;
7816                        }
7817                        GeneratedField::WatermarkExprIndices => {
7818                            if watermark_expr_indices__.is_some() {
7819                                return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
7820                            }
7821                            watermark_expr_indices__ = 
7822                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7823                                    .into_iter().map(|x| x.0).collect())
7824                            ;
7825                        }
7826                        GeneratedField::NondecreasingExprs => {
7827                            if nondecreasing_exprs__.is_some() {
7828                                return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
7829                            }
7830                            nondecreasing_exprs__ = 
7831                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7832                                    .into_iter().map(|x| x.0).collect())
7833                            ;
7834                        }
7835                    }
7836                }
7837                Ok(ProjectSetNode {
7838                    select_list: select_list__.unwrap_or_default(),
7839                    watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
7840                    watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
7841                    nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
7842                })
7843            }
7844        }
7845        deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
7846    }
7847}
7848impl serde::Serialize for ResumeMutation {
7849    #[allow(deprecated)]
7850    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7851    where
7852        S: serde::Serializer,
7853    {
7854        use serde::ser::SerializeStruct;
7855        let len = 0;
7856        let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
7857        struct_ser.end()
7858    }
7859}
7860impl<'de> serde::Deserialize<'de> for ResumeMutation {
7861    #[allow(deprecated)]
7862    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7863    where
7864        D: serde::Deserializer<'de>,
7865    {
7866        const FIELDS: &[&str] = &[
7867        ];
7868
7869        #[allow(clippy::enum_variant_names)]
7870        enum GeneratedField {
7871        }
7872        impl<'de> serde::Deserialize<'de> for GeneratedField {
7873            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7874            where
7875                D: serde::Deserializer<'de>,
7876            {
7877                struct GeneratedVisitor;
7878
7879                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7880                    type Value = GeneratedField;
7881
7882                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7883                        write!(formatter, "expected one of: {:?}", &FIELDS)
7884                    }
7885
7886                    #[allow(unused_variables)]
7887                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7888                    where
7889                        E: serde::de::Error,
7890                    {
7891                            Err(serde::de::Error::unknown_field(value, FIELDS))
7892                    }
7893                }
7894                deserializer.deserialize_identifier(GeneratedVisitor)
7895            }
7896        }
7897        struct GeneratedVisitor;
7898        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7899            type Value = ResumeMutation;
7900
7901            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7902                formatter.write_str("struct stream_plan.ResumeMutation")
7903            }
7904
7905            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
7906                where
7907                    V: serde::de::MapAccess<'de>,
7908            {
7909                while map_.next_key::<GeneratedField>()?.is_some() {
7910                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7911                }
7912                Ok(ResumeMutation {
7913                })
7914            }
7915        }
7916        deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
7917    }
7918}
7919impl serde::Serialize for RowIdGenNode {
7920    #[allow(deprecated)]
7921    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7922    where
7923        S: serde::Serializer,
7924    {
7925        use serde::ser::SerializeStruct;
7926        let mut len = 0;
7927        if self.row_id_index != 0 {
7928            len += 1;
7929        }
7930        let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
7931        if self.row_id_index != 0 {
7932            #[allow(clippy::needless_borrow)]
7933            #[allow(clippy::needless_borrows_for_generic_args)]
7934            struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
7935        }
7936        struct_ser.end()
7937    }
7938}
7939impl<'de> serde::Deserialize<'de> for RowIdGenNode {
7940    #[allow(deprecated)]
7941    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7942    where
7943        D: serde::Deserializer<'de>,
7944    {
7945        const FIELDS: &[&str] = &[
7946            "row_id_index",
7947            "rowIdIndex",
7948        ];
7949
7950        #[allow(clippy::enum_variant_names)]
7951        enum GeneratedField {
7952            RowIdIndex,
7953        }
7954        impl<'de> serde::Deserialize<'de> for GeneratedField {
7955            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7956            where
7957                D: serde::Deserializer<'de>,
7958            {
7959                struct GeneratedVisitor;
7960
7961                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7962                    type Value = GeneratedField;
7963
7964                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7965                        write!(formatter, "expected one of: {:?}", &FIELDS)
7966                    }
7967
7968                    #[allow(unused_variables)]
7969                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7970                    where
7971                        E: serde::de::Error,
7972                    {
7973                        match value {
7974                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
7975                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7976                        }
7977                    }
7978                }
7979                deserializer.deserialize_identifier(GeneratedVisitor)
7980            }
7981        }
7982        struct GeneratedVisitor;
7983        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7984            type Value = RowIdGenNode;
7985
7986            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7987                formatter.write_str("struct stream_plan.RowIdGenNode")
7988            }
7989
7990            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
7991                where
7992                    V: serde::de::MapAccess<'de>,
7993            {
7994                let mut row_id_index__ = None;
7995                while let Some(k) = map_.next_key()? {
7996                    match k {
7997                        GeneratedField::RowIdIndex => {
7998                            if row_id_index__.is_some() {
7999                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
8000                            }
8001                            row_id_index__ = 
8002                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8003                            ;
8004                        }
8005                    }
8006                }
8007                Ok(RowIdGenNode {
8008                    row_id_index: row_id_index__.unwrap_or_default(),
8009                })
8010            }
8011        }
8012        deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
8013    }
8014}
8015impl serde::Serialize for RowMergeNode {
8016    #[allow(deprecated)]
8017    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8018    where
8019        S: serde::Serializer,
8020    {
8021        use serde::ser::SerializeStruct;
8022        let mut len = 0;
8023        if self.lhs_mapping.is_some() {
8024            len += 1;
8025        }
8026        if self.rhs_mapping.is_some() {
8027            len += 1;
8028        }
8029        let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
8030        if let Some(v) = self.lhs_mapping.as_ref() {
8031            struct_ser.serialize_field("lhsMapping", v)?;
8032        }
8033        if let Some(v) = self.rhs_mapping.as_ref() {
8034            struct_ser.serialize_field("rhsMapping", v)?;
8035        }
8036        struct_ser.end()
8037    }
8038}
8039impl<'de> serde::Deserialize<'de> for RowMergeNode {
8040    #[allow(deprecated)]
8041    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8042    where
8043        D: serde::Deserializer<'de>,
8044    {
8045        const FIELDS: &[&str] = &[
8046            "lhs_mapping",
8047            "lhsMapping",
8048            "rhs_mapping",
8049            "rhsMapping",
8050        ];
8051
8052        #[allow(clippy::enum_variant_names)]
8053        enum GeneratedField {
8054            LhsMapping,
8055            RhsMapping,
8056        }
8057        impl<'de> serde::Deserialize<'de> for GeneratedField {
8058            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8059            where
8060                D: serde::Deserializer<'de>,
8061            {
8062                struct GeneratedVisitor;
8063
8064                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8065                    type Value = GeneratedField;
8066
8067                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8068                        write!(formatter, "expected one of: {:?}", &FIELDS)
8069                    }
8070
8071                    #[allow(unused_variables)]
8072                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8073                    where
8074                        E: serde::de::Error,
8075                    {
8076                        match value {
8077                            "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
8078                            "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
8079                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8080                        }
8081                    }
8082                }
8083                deserializer.deserialize_identifier(GeneratedVisitor)
8084            }
8085        }
8086        struct GeneratedVisitor;
8087        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8088            type Value = RowMergeNode;
8089
8090            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8091                formatter.write_str("struct stream_plan.RowMergeNode")
8092            }
8093
8094            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
8095                where
8096                    V: serde::de::MapAccess<'de>,
8097            {
8098                let mut lhs_mapping__ = None;
8099                let mut rhs_mapping__ = None;
8100                while let Some(k) = map_.next_key()? {
8101                    match k {
8102                        GeneratedField::LhsMapping => {
8103                            if lhs_mapping__.is_some() {
8104                                return Err(serde::de::Error::duplicate_field("lhsMapping"));
8105                            }
8106                            lhs_mapping__ = map_.next_value()?;
8107                        }
8108                        GeneratedField::RhsMapping => {
8109                            if rhs_mapping__.is_some() {
8110                                return Err(serde::de::Error::duplicate_field("rhsMapping"));
8111                            }
8112                            rhs_mapping__ = map_.next_value()?;
8113                        }
8114                    }
8115                }
8116                Ok(RowMergeNode {
8117                    lhs_mapping: lhs_mapping__,
8118                    rhs_mapping: rhs_mapping__,
8119                })
8120            }
8121        }
8122        deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
8123    }
8124}
8125impl serde::Serialize for SimpleAggNode {
8126    #[allow(deprecated)]
8127    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8128    where
8129        S: serde::Serializer,
8130    {
8131        use serde::ser::SerializeStruct;
8132        let mut len = 0;
8133        if !self.agg_calls.is_empty() {
8134            len += 1;
8135        }
8136        if !self.distribution_key.is_empty() {
8137            len += 1;
8138        }
8139        if !self.agg_call_states.is_empty() {
8140            len += 1;
8141        }
8142        if self.intermediate_state_table.is_some() {
8143            len += 1;
8144        }
8145        if self.is_append_only {
8146            len += 1;
8147        }
8148        if !self.distinct_dedup_tables.is_empty() {
8149            len += 1;
8150        }
8151        if self.row_count_index != 0 {
8152            len += 1;
8153        }
8154        if self.version != 0 {
8155            len += 1;
8156        }
8157        if self.must_output_per_barrier {
8158            len += 1;
8159        }
8160        let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
8161        if !self.agg_calls.is_empty() {
8162            struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
8163        }
8164        if !self.distribution_key.is_empty() {
8165            struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
8166        }
8167        if !self.agg_call_states.is_empty() {
8168            struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
8169        }
8170        if let Some(v) = self.intermediate_state_table.as_ref() {
8171            struct_ser.serialize_field("intermediateStateTable", v)?;
8172        }
8173        if self.is_append_only {
8174            struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
8175        }
8176        if !self.distinct_dedup_tables.is_empty() {
8177            struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
8178        }
8179        if self.row_count_index != 0 {
8180            struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
8181        }
8182        if self.version != 0 {
8183            let v = AggNodeVersion::try_from(self.version)
8184                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
8185            struct_ser.serialize_field("version", &v)?;
8186        }
8187        if self.must_output_per_barrier {
8188            struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
8189        }
8190        struct_ser.end()
8191    }
8192}
8193impl<'de> serde::Deserialize<'de> for SimpleAggNode {
8194    #[allow(deprecated)]
8195    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8196    where
8197        D: serde::Deserializer<'de>,
8198    {
8199        const FIELDS: &[&str] = &[
8200            "agg_calls",
8201            "aggCalls",
8202            "distribution_key",
8203            "distributionKey",
8204            "agg_call_states",
8205            "aggCallStates",
8206            "intermediate_state_table",
8207            "intermediateStateTable",
8208            "is_append_only",
8209            "isAppendOnly",
8210            "distinct_dedup_tables",
8211            "distinctDedupTables",
8212            "row_count_index",
8213            "rowCountIndex",
8214            "version",
8215            "must_output_per_barrier",
8216            "mustOutputPerBarrier",
8217        ];
8218
8219        #[allow(clippy::enum_variant_names)]
8220        enum GeneratedField {
8221            AggCalls,
8222            DistributionKey,
8223            AggCallStates,
8224            IntermediateStateTable,
8225            IsAppendOnly,
8226            DistinctDedupTables,
8227            RowCountIndex,
8228            Version,
8229            MustOutputPerBarrier,
8230        }
8231        impl<'de> serde::Deserialize<'de> for GeneratedField {
8232            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8233            where
8234                D: serde::Deserializer<'de>,
8235            {
8236                struct GeneratedVisitor;
8237
8238                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8239                    type Value = GeneratedField;
8240
8241                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8242                        write!(formatter, "expected one of: {:?}", &FIELDS)
8243                    }
8244
8245                    #[allow(unused_variables)]
8246                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8247                    where
8248                        E: serde::de::Error,
8249                    {
8250                        match value {
8251                            "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
8252                            "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
8253                            "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
8254                            "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
8255                            "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
8256                            "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
8257                            "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
8258                            "version" => Ok(GeneratedField::Version),
8259                            "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
8260                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8261                        }
8262                    }
8263                }
8264                deserializer.deserialize_identifier(GeneratedVisitor)
8265            }
8266        }
8267        struct GeneratedVisitor;
8268        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8269            type Value = SimpleAggNode;
8270
8271            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8272                formatter.write_str("struct stream_plan.SimpleAggNode")
8273            }
8274
8275            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
8276                where
8277                    V: serde::de::MapAccess<'de>,
8278            {
8279                let mut agg_calls__ = None;
8280                let mut distribution_key__ = None;
8281                let mut agg_call_states__ = None;
8282                let mut intermediate_state_table__ = None;
8283                let mut is_append_only__ = None;
8284                let mut distinct_dedup_tables__ = None;
8285                let mut row_count_index__ = None;
8286                let mut version__ = None;
8287                let mut must_output_per_barrier__ = None;
8288                while let Some(k) = map_.next_key()? {
8289                    match k {
8290                        GeneratedField::AggCalls => {
8291                            if agg_calls__.is_some() {
8292                                return Err(serde::de::Error::duplicate_field("aggCalls"));
8293                            }
8294                            agg_calls__ = Some(map_.next_value()?);
8295                        }
8296                        GeneratedField::DistributionKey => {
8297                            if distribution_key__.is_some() {
8298                                return Err(serde::de::Error::duplicate_field("distributionKey"));
8299                            }
8300                            distribution_key__ = 
8301                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8302                                    .into_iter().map(|x| x.0).collect())
8303                            ;
8304                        }
8305                        GeneratedField::AggCallStates => {
8306                            if agg_call_states__.is_some() {
8307                                return Err(serde::de::Error::duplicate_field("aggCallStates"));
8308                            }
8309                            agg_call_states__ = Some(map_.next_value()?);
8310                        }
8311                        GeneratedField::IntermediateStateTable => {
8312                            if intermediate_state_table__.is_some() {
8313                                return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
8314                            }
8315                            intermediate_state_table__ = map_.next_value()?;
8316                        }
8317                        GeneratedField::IsAppendOnly => {
8318                            if is_append_only__.is_some() {
8319                                return Err(serde::de::Error::duplicate_field("isAppendOnly"));
8320                            }
8321                            is_append_only__ = Some(map_.next_value()?);
8322                        }
8323                        GeneratedField::DistinctDedupTables => {
8324                            if distinct_dedup_tables__.is_some() {
8325                                return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
8326                            }
8327                            distinct_dedup_tables__ = Some(
8328                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8329                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
8330                            );
8331                        }
8332                        GeneratedField::RowCountIndex => {
8333                            if row_count_index__.is_some() {
8334                                return Err(serde::de::Error::duplicate_field("rowCountIndex"));
8335                            }
8336                            row_count_index__ = 
8337                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8338                            ;
8339                        }
8340                        GeneratedField::Version => {
8341                            if version__.is_some() {
8342                                return Err(serde::de::Error::duplicate_field("version"));
8343                            }
8344                            version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
8345                        }
8346                        GeneratedField::MustOutputPerBarrier => {
8347                            if must_output_per_barrier__.is_some() {
8348                                return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
8349                            }
8350                            must_output_per_barrier__ = Some(map_.next_value()?);
8351                        }
8352                    }
8353                }
8354                Ok(SimpleAggNode {
8355                    agg_calls: agg_calls__.unwrap_or_default(),
8356                    distribution_key: distribution_key__.unwrap_or_default(),
8357                    agg_call_states: agg_call_states__.unwrap_or_default(),
8358                    intermediate_state_table: intermediate_state_table__,
8359                    is_append_only: is_append_only__.unwrap_or_default(),
8360                    distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
8361                    row_count_index: row_count_index__.unwrap_or_default(),
8362                    version: version__.unwrap_or_default(),
8363                    must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
8364                })
8365            }
8366        }
8367        deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
8368    }
8369}
8370impl serde::Serialize for SinkDesc {
8371    #[allow(deprecated)]
8372    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8373    where
8374        S: serde::Serializer,
8375    {
8376        use serde::ser::SerializeStruct;
8377        let mut len = 0;
8378        if self.id != 0 {
8379            len += 1;
8380        }
8381        if !self.name.is_empty() {
8382            len += 1;
8383        }
8384        if !self.definition.is_empty() {
8385            len += 1;
8386        }
8387        if !self.plan_pk.is_empty() {
8388            len += 1;
8389        }
8390        if !self.downstream_pk.is_empty() {
8391            len += 1;
8392        }
8393        if !self.distribution_key.is_empty() {
8394            len += 1;
8395        }
8396        if !self.properties.is_empty() {
8397            len += 1;
8398        }
8399        if self.sink_type != 0 {
8400            len += 1;
8401        }
8402        if !self.column_catalogs.is_empty() {
8403            len += 1;
8404        }
8405        if !self.db_name.is_empty() {
8406            len += 1;
8407        }
8408        if !self.sink_from_name.is_empty() {
8409            len += 1;
8410        }
8411        if self.format_desc.is_some() {
8412            len += 1;
8413        }
8414        if self.target_table.is_some() {
8415            len += 1;
8416        }
8417        if self.extra_partition_col_idx.is_some() {
8418            len += 1;
8419        }
8420        if !self.secret_refs.is_empty() {
8421            len += 1;
8422        }
8423        let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
8424        if self.id != 0 {
8425            struct_ser.serialize_field("id", &self.id)?;
8426        }
8427        if !self.name.is_empty() {
8428            struct_ser.serialize_field("name", &self.name)?;
8429        }
8430        if !self.definition.is_empty() {
8431            struct_ser.serialize_field("definition", &self.definition)?;
8432        }
8433        if !self.plan_pk.is_empty() {
8434            struct_ser.serialize_field("planPk", &self.plan_pk)?;
8435        }
8436        if !self.downstream_pk.is_empty() {
8437            struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
8438        }
8439        if !self.distribution_key.is_empty() {
8440            struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
8441        }
8442        if !self.properties.is_empty() {
8443            struct_ser.serialize_field("properties", &self.properties)?;
8444        }
8445        if self.sink_type != 0 {
8446            let v = super::catalog::SinkType::try_from(self.sink_type)
8447                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
8448            struct_ser.serialize_field("sinkType", &v)?;
8449        }
8450        if !self.column_catalogs.is_empty() {
8451            struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
8452        }
8453        if !self.db_name.is_empty() {
8454            struct_ser.serialize_field("dbName", &self.db_name)?;
8455        }
8456        if !self.sink_from_name.is_empty() {
8457            struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
8458        }
8459        if let Some(v) = self.format_desc.as_ref() {
8460            struct_ser.serialize_field("formatDesc", v)?;
8461        }
8462        if let Some(v) = self.target_table.as_ref() {
8463            struct_ser.serialize_field("targetTable", v)?;
8464        }
8465        if let Some(v) = self.extra_partition_col_idx.as_ref() {
8466            #[allow(clippy::needless_borrow)]
8467            #[allow(clippy::needless_borrows_for_generic_args)]
8468            struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
8469        }
8470        if !self.secret_refs.is_empty() {
8471            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
8472        }
8473        struct_ser.end()
8474    }
8475}
8476impl<'de> serde::Deserialize<'de> for SinkDesc {
8477    #[allow(deprecated)]
8478    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8479    where
8480        D: serde::Deserializer<'de>,
8481    {
8482        const FIELDS: &[&str] = &[
8483            "id",
8484            "name",
8485            "definition",
8486            "plan_pk",
8487            "planPk",
8488            "downstream_pk",
8489            "downstreamPk",
8490            "distribution_key",
8491            "distributionKey",
8492            "properties",
8493            "sink_type",
8494            "sinkType",
8495            "column_catalogs",
8496            "columnCatalogs",
8497            "db_name",
8498            "dbName",
8499            "sink_from_name",
8500            "sinkFromName",
8501            "format_desc",
8502            "formatDesc",
8503            "target_table",
8504            "targetTable",
8505            "extra_partition_col_idx",
8506            "extraPartitionColIdx",
8507            "secret_refs",
8508            "secretRefs",
8509        ];
8510
8511        #[allow(clippy::enum_variant_names)]
8512        enum GeneratedField {
8513            Id,
8514            Name,
8515            Definition,
8516            PlanPk,
8517            DownstreamPk,
8518            DistributionKey,
8519            Properties,
8520            SinkType,
8521            ColumnCatalogs,
8522            DbName,
8523            SinkFromName,
8524            FormatDesc,
8525            TargetTable,
8526            ExtraPartitionColIdx,
8527            SecretRefs,
8528        }
8529        impl<'de> serde::Deserialize<'de> for GeneratedField {
8530            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8531            where
8532                D: serde::Deserializer<'de>,
8533            {
8534                struct GeneratedVisitor;
8535
8536                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8537                    type Value = GeneratedField;
8538
8539                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8540                        write!(formatter, "expected one of: {:?}", &FIELDS)
8541                    }
8542
8543                    #[allow(unused_variables)]
8544                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8545                    where
8546                        E: serde::de::Error,
8547                    {
8548                        match value {
8549                            "id" => Ok(GeneratedField::Id),
8550                            "name" => Ok(GeneratedField::Name),
8551                            "definition" => Ok(GeneratedField::Definition),
8552                            "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
8553                            "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
8554                            "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
8555                            "properties" => Ok(GeneratedField::Properties),
8556                            "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
8557                            "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
8558                            "dbName" | "db_name" => Ok(GeneratedField::DbName),
8559                            "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
8560                            "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
8561                            "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
8562                            "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
8563                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
8564                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8565                        }
8566                    }
8567                }
8568                deserializer.deserialize_identifier(GeneratedVisitor)
8569            }
8570        }
8571        struct GeneratedVisitor;
8572        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8573            type Value = SinkDesc;
8574
8575            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8576                formatter.write_str("struct stream_plan.SinkDesc")
8577            }
8578
8579            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
8580                where
8581                    V: serde::de::MapAccess<'de>,
8582            {
8583                let mut id__ = None;
8584                let mut name__ = None;
8585                let mut definition__ = None;
8586                let mut plan_pk__ = None;
8587                let mut downstream_pk__ = None;
8588                let mut distribution_key__ = None;
8589                let mut properties__ = None;
8590                let mut sink_type__ = None;
8591                let mut column_catalogs__ = None;
8592                let mut db_name__ = None;
8593                let mut sink_from_name__ = None;
8594                let mut format_desc__ = None;
8595                let mut target_table__ = None;
8596                let mut extra_partition_col_idx__ = None;
8597                let mut secret_refs__ = None;
8598                while let Some(k) = map_.next_key()? {
8599                    match k {
8600                        GeneratedField::Id => {
8601                            if id__.is_some() {
8602                                return Err(serde::de::Error::duplicate_field("id"));
8603                            }
8604                            id__ = 
8605                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8606                            ;
8607                        }
8608                        GeneratedField::Name => {
8609                            if name__.is_some() {
8610                                return Err(serde::de::Error::duplicate_field("name"));
8611                            }
8612                            name__ = Some(map_.next_value()?);
8613                        }
8614                        GeneratedField::Definition => {
8615                            if definition__.is_some() {
8616                                return Err(serde::de::Error::duplicate_field("definition"));
8617                            }
8618                            definition__ = Some(map_.next_value()?);
8619                        }
8620                        GeneratedField::PlanPk => {
8621                            if plan_pk__.is_some() {
8622                                return Err(serde::de::Error::duplicate_field("planPk"));
8623                            }
8624                            plan_pk__ = Some(map_.next_value()?);
8625                        }
8626                        GeneratedField::DownstreamPk => {
8627                            if downstream_pk__.is_some() {
8628                                return Err(serde::de::Error::duplicate_field("downstreamPk"));
8629                            }
8630                            downstream_pk__ = 
8631                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8632                                    .into_iter().map(|x| x.0).collect())
8633                            ;
8634                        }
8635                        GeneratedField::DistributionKey => {
8636                            if distribution_key__.is_some() {
8637                                return Err(serde::de::Error::duplicate_field("distributionKey"));
8638                            }
8639                            distribution_key__ = 
8640                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8641                                    .into_iter().map(|x| x.0).collect())
8642                            ;
8643                        }
8644                        GeneratedField::Properties => {
8645                            if properties__.is_some() {
8646                                return Err(serde::de::Error::duplicate_field("properties"));
8647                            }
8648                            properties__ = Some(
8649                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
8650                            );
8651                        }
8652                        GeneratedField::SinkType => {
8653                            if sink_type__.is_some() {
8654                                return Err(serde::de::Error::duplicate_field("sinkType"));
8655                            }
8656                            sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
8657                        }
8658                        GeneratedField::ColumnCatalogs => {
8659                            if column_catalogs__.is_some() {
8660                                return Err(serde::de::Error::duplicate_field("columnCatalogs"));
8661                            }
8662                            column_catalogs__ = Some(map_.next_value()?);
8663                        }
8664                        GeneratedField::DbName => {
8665                            if db_name__.is_some() {
8666                                return Err(serde::de::Error::duplicate_field("dbName"));
8667                            }
8668                            db_name__ = Some(map_.next_value()?);
8669                        }
8670                        GeneratedField::SinkFromName => {
8671                            if sink_from_name__.is_some() {
8672                                return Err(serde::de::Error::duplicate_field("sinkFromName"));
8673                            }
8674                            sink_from_name__ = Some(map_.next_value()?);
8675                        }
8676                        GeneratedField::FormatDesc => {
8677                            if format_desc__.is_some() {
8678                                return Err(serde::de::Error::duplicate_field("formatDesc"));
8679                            }
8680                            format_desc__ = map_.next_value()?;
8681                        }
8682                        GeneratedField::TargetTable => {
8683                            if target_table__.is_some() {
8684                                return Err(serde::de::Error::duplicate_field("targetTable"));
8685                            }
8686                            target_table__ = 
8687                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8688                            ;
8689                        }
8690                        GeneratedField::ExtraPartitionColIdx => {
8691                            if extra_partition_col_idx__.is_some() {
8692                                return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
8693                            }
8694                            extra_partition_col_idx__ = 
8695                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8696                            ;
8697                        }
8698                        GeneratedField::SecretRefs => {
8699                            if secret_refs__.is_some() {
8700                                return Err(serde::de::Error::duplicate_field("secretRefs"));
8701                            }
8702                            secret_refs__ = Some(
8703                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
8704                            );
8705                        }
8706                    }
8707                }
8708                Ok(SinkDesc {
8709                    id: id__.unwrap_or_default(),
8710                    name: name__.unwrap_or_default(),
8711                    definition: definition__.unwrap_or_default(),
8712                    plan_pk: plan_pk__.unwrap_or_default(),
8713                    downstream_pk: downstream_pk__.unwrap_or_default(),
8714                    distribution_key: distribution_key__.unwrap_or_default(),
8715                    properties: properties__.unwrap_or_default(),
8716                    sink_type: sink_type__.unwrap_or_default(),
8717                    column_catalogs: column_catalogs__.unwrap_or_default(),
8718                    db_name: db_name__.unwrap_or_default(),
8719                    sink_from_name: sink_from_name__.unwrap_or_default(),
8720                    format_desc: format_desc__,
8721                    target_table: target_table__,
8722                    extra_partition_col_idx: extra_partition_col_idx__,
8723                    secret_refs: secret_refs__.unwrap_or_default(),
8724                })
8725            }
8726        }
8727        deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
8728    }
8729}
8730impl serde::Serialize for SinkLogStoreType {
8731    #[allow(deprecated)]
8732    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8733    where
8734        S: serde::Serializer,
8735    {
8736        let variant = match self {
8737            Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
8738            Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
8739            Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
8740        };
8741        serializer.serialize_str(variant)
8742    }
8743}
8744impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
8745    #[allow(deprecated)]
8746    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8747    where
8748        D: serde::Deserializer<'de>,
8749    {
8750        const FIELDS: &[&str] = &[
8751            "SINK_LOG_STORE_TYPE_UNSPECIFIED",
8752            "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
8753            "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
8754        ];
8755
8756        struct GeneratedVisitor;
8757
8758        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8759            type Value = SinkLogStoreType;
8760
8761            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8762                write!(formatter, "expected one of: {:?}", &FIELDS)
8763            }
8764
8765            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8766            where
8767                E: serde::de::Error,
8768            {
8769                i32::try_from(v)
8770                    .ok()
8771                    .and_then(|x| x.try_into().ok())
8772                    .ok_or_else(|| {
8773                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8774                    })
8775            }
8776
8777            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8778            where
8779                E: serde::de::Error,
8780            {
8781                i32::try_from(v)
8782                    .ok()
8783                    .and_then(|x| x.try_into().ok())
8784                    .ok_or_else(|| {
8785                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8786                    })
8787            }
8788
8789            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8790            where
8791                E: serde::de::Error,
8792            {
8793                match value {
8794                    "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
8795                    "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
8796                    "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
8797                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8798                }
8799            }
8800        }
8801        deserializer.deserialize_any(GeneratedVisitor)
8802    }
8803}
8804impl serde::Serialize for SinkNode {
8805    #[allow(deprecated)]
8806    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8807    where
8808        S: serde::Serializer,
8809    {
8810        use serde::ser::SerializeStruct;
8811        let mut len = 0;
8812        if self.sink_desc.is_some() {
8813            len += 1;
8814        }
8815        if self.table.is_some() {
8816            len += 1;
8817        }
8818        if self.log_store_type != 0 {
8819            len += 1;
8820        }
8821        if self.rate_limit.is_some() {
8822            len += 1;
8823        }
8824        let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
8825        if let Some(v) = self.sink_desc.as_ref() {
8826            struct_ser.serialize_field("sinkDesc", v)?;
8827        }
8828        if let Some(v) = self.table.as_ref() {
8829            struct_ser.serialize_field("table", v)?;
8830        }
8831        if self.log_store_type != 0 {
8832            let v = SinkLogStoreType::try_from(self.log_store_type)
8833                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
8834            struct_ser.serialize_field("logStoreType", &v)?;
8835        }
8836        if let Some(v) = self.rate_limit.as_ref() {
8837            struct_ser.serialize_field("rateLimit", v)?;
8838        }
8839        struct_ser.end()
8840    }
8841}
8842impl<'de> serde::Deserialize<'de> for SinkNode {
8843    #[allow(deprecated)]
8844    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8845    where
8846        D: serde::Deserializer<'de>,
8847    {
8848        const FIELDS: &[&str] = &[
8849            "sink_desc",
8850            "sinkDesc",
8851            "table",
8852            "log_store_type",
8853            "logStoreType",
8854            "rate_limit",
8855            "rateLimit",
8856        ];
8857
8858        #[allow(clippy::enum_variant_names)]
8859        enum GeneratedField {
8860            SinkDesc,
8861            Table,
8862            LogStoreType,
8863            RateLimit,
8864        }
8865        impl<'de> serde::Deserialize<'de> for GeneratedField {
8866            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8867            where
8868                D: serde::Deserializer<'de>,
8869            {
8870                struct GeneratedVisitor;
8871
8872                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8873                    type Value = GeneratedField;
8874
8875                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8876                        write!(formatter, "expected one of: {:?}", &FIELDS)
8877                    }
8878
8879                    #[allow(unused_variables)]
8880                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8881                    where
8882                        E: serde::de::Error,
8883                    {
8884                        match value {
8885                            "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
8886                            "table" => Ok(GeneratedField::Table),
8887                            "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
8888                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
8889                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8890                        }
8891                    }
8892                }
8893                deserializer.deserialize_identifier(GeneratedVisitor)
8894            }
8895        }
8896        struct GeneratedVisitor;
8897        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8898            type Value = SinkNode;
8899
8900            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8901                formatter.write_str("struct stream_plan.SinkNode")
8902            }
8903
8904            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
8905                where
8906                    V: serde::de::MapAccess<'de>,
8907            {
8908                let mut sink_desc__ = None;
8909                let mut table__ = None;
8910                let mut log_store_type__ = None;
8911                let mut rate_limit__ = None;
8912                while let Some(k) = map_.next_key()? {
8913                    match k {
8914                        GeneratedField::SinkDesc => {
8915                            if sink_desc__.is_some() {
8916                                return Err(serde::de::Error::duplicate_field("sinkDesc"));
8917                            }
8918                            sink_desc__ = map_.next_value()?;
8919                        }
8920                        GeneratedField::Table => {
8921                            if table__.is_some() {
8922                                return Err(serde::de::Error::duplicate_field("table"));
8923                            }
8924                            table__ = map_.next_value()?;
8925                        }
8926                        GeneratedField::LogStoreType => {
8927                            if log_store_type__.is_some() {
8928                                return Err(serde::de::Error::duplicate_field("logStoreType"));
8929                            }
8930                            log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
8931                        }
8932                        GeneratedField::RateLimit => {
8933                            if rate_limit__.is_some() {
8934                                return Err(serde::de::Error::duplicate_field("rateLimit"));
8935                            }
8936                            rate_limit__ = 
8937                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8938                            ;
8939                        }
8940                    }
8941                }
8942                Ok(SinkNode {
8943                    sink_desc: sink_desc__,
8944                    table: table__,
8945                    log_store_type: log_store_type__.unwrap_or_default(),
8946                    rate_limit: rate_limit__,
8947                })
8948            }
8949        }
8950        deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
8951    }
8952}
8953impl serde::Serialize for SortNode {
8954    #[allow(deprecated)]
8955    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8956    where
8957        S: serde::Serializer,
8958    {
8959        use serde::ser::SerializeStruct;
8960        let mut len = 0;
8961        if self.state_table.is_some() {
8962            len += 1;
8963        }
8964        if self.sort_column_index != 0 {
8965            len += 1;
8966        }
8967        let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
8968        if let Some(v) = self.state_table.as_ref() {
8969            struct_ser.serialize_field("stateTable", v)?;
8970        }
8971        if self.sort_column_index != 0 {
8972            struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
8973        }
8974        struct_ser.end()
8975    }
8976}
8977impl<'de> serde::Deserialize<'de> for SortNode {
8978    #[allow(deprecated)]
8979    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8980    where
8981        D: serde::Deserializer<'de>,
8982    {
8983        const FIELDS: &[&str] = &[
8984            "state_table",
8985            "stateTable",
8986            "sort_column_index",
8987            "sortColumnIndex",
8988        ];
8989
8990        #[allow(clippy::enum_variant_names)]
8991        enum GeneratedField {
8992            StateTable,
8993            SortColumnIndex,
8994        }
8995        impl<'de> serde::Deserialize<'de> for GeneratedField {
8996            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8997            where
8998                D: serde::Deserializer<'de>,
8999            {
9000                struct GeneratedVisitor;
9001
9002                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9003                    type Value = GeneratedField;
9004
9005                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9006                        write!(formatter, "expected one of: {:?}", &FIELDS)
9007                    }
9008
9009                    #[allow(unused_variables)]
9010                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9011                    where
9012                        E: serde::de::Error,
9013                    {
9014                        match value {
9015                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9016                            "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
9017                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9018                        }
9019                    }
9020                }
9021                deserializer.deserialize_identifier(GeneratedVisitor)
9022            }
9023        }
9024        struct GeneratedVisitor;
9025        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9026            type Value = SortNode;
9027
9028            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9029                formatter.write_str("struct stream_plan.SortNode")
9030            }
9031
9032            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
9033                where
9034                    V: serde::de::MapAccess<'de>,
9035            {
9036                let mut state_table__ = None;
9037                let mut sort_column_index__ = None;
9038                while let Some(k) = map_.next_key()? {
9039                    match k {
9040                        GeneratedField::StateTable => {
9041                            if state_table__.is_some() {
9042                                return Err(serde::de::Error::duplicate_field("stateTable"));
9043                            }
9044                            state_table__ = map_.next_value()?;
9045                        }
9046                        GeneratedField::SortColumnIndex => {
9047                            if sort_column_index__.is_some() {
9048                                return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
9049                            }
9050                            sort_column_index__ = 
9051                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9052                            ;
9053                        }
9054                    }
9055                }
9056                Ok(SortNode {
9057                    state_table: state_table__,
9058                    sort_column_index: sort_column_index__.unwrap_or_default(),
9059                })
9060            }
9061        }
9062        deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
9063    }
9064}
9065impl serde::Serialize for SourceBackfillNode {
9066    #[allow(deprecated)]
9067    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9068    where
9069        S: serde::Serializer,
9070    {
9071        use serde::ser::SerializeStruct;
9072        let mut len = 0;
9073        if self.upstream_source_id != 0 {
9074            len += 1;
9075        }
9076        if self.row_id_index.is_some() {
9077            len += 1;
9078        }
9079        if !self.columns.is_empty() {
9080            len += 1;
9081        }
9082        if self.info.is_some() {
9083            len += 1;
9084        }
9085        if !self.source_name.is_empty() {
9086            len += 1;
9087        }
9088        if !self.with_properties.is_empty() {
9089            len += 1;
9090        }
9091        if self.rate_limit.is_some() {
9092            len += 1;
9093        }
9094        if self.state_table.is_some() {
9095            len += 1;
9096        }
9097        if !self.secret_refs.is_empty() {
9098            len += 1;
9099        }
9100        let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
9101        if self.upstream_source_id != 0 {
9102            struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
9103        }
9104        if let Some(v) = self.row_id_index.as_ref() {
9105            struct_ser.serialize_field("rowIdIndex", v)?;
9106        }
9107        if !self.columns.is_empty() {
9108            struct_ser.serialize_field("columns", &self.columns)?;
9109        }
9110        if let Some(v) = self.info.as_ref() {
9111            struct_ser.serialize_field("info", v)?;
9112        }
9113        if !self.source_name.is_empty() {
9114            struct_ser.serialize_field("sourceName", &self.source_name)?;
9115        }
9116        if !self.with_properties.is_empty() {
9117            struct_ser.serialize_field("withProperties", &self.with_properties)?;
9118        }
9119        if let Some(v) = self.rate_limit.as_ref() {
9120            struct_ser.serialize_field("rateLimit", v)?;
9121        }
9122        if let Some(v) = self.state_table.as_ref() {
9123            struct_ser.serialize_field("stateTable", v)?;
9124        }
9125        if !self.secret_refs.is_empty() {
9126            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
9127        }
9128        struct_ser.end()
9129    }
9130}
9131impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
9132    #[allow(deprecated)]
9133    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9134    where
9135        D: serde::Deserializer<'de>,
9136    {
9137        const FIELDS: &[&str] = &[
9138            "upstream_source_id",
9139            "upstreamSourceId",
9140            "row_id_index",
9141            "rowIdIndex",
9142            "columns",
9143            "info",
9144            "source_name",
9145            "sourceName",
9146            "with_properties",
9147            "withProperties",
9148            "rate_limit",
9149            "rateLimit",
9150            "state_table",
9151            "stateTable",
9152            "secret_refs",
9153            "secretRefs",
9154        ];
9155
9156        #[allow(clippy::enum_variant_names)]
9157        enum GeneratedField {
9158            UpstreamSourceId,
9159            RowIdIndex,
9160            Columns,
9161            Info,
9162            SourceName,
9163            WithProperties,
9164            RateLimit,
9165            StateTable,
9166            SecretRefs,
9167        }
9168        impl<'de> serde::Deserialize<'de> for GeneratedField {
9169            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9170            where
9171                D: serde::Deserializer<'de>,
9172            {
9173                struct GeneratedVisitor;
9174
9175                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9176                    type Value = GeneratedField;
9177
9178                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9179                        write!(formatter, "expected one of: {:?}", &FIELDS)
9180                    }
9181
9182                    #[allow(unused_variables)]
9183                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9184                    where
9185                        E: serde::de::Error,
9186                    {
9187                        match value {
9188                            "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
9189                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
9190                            "columns" => Ok(GeneratedField::Columns),
9191                            "info" => Ok(GeneratedField::Info),
9192                            "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
9193                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
9194                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9195                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9196                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9197                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9198                        }
9199                    }
9200                }
9201                deserializer.deserialize_identifier(GeneratedVisitor)
9202            }
9203        }
9204        struct GeneratedVisitor;
9205        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9206            type Value = SourceBackfillNode;
9207
9208            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9209                formatter.write_str("struct stream_plan.SourceBackfillNode")
9210            }
9211
9212            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
9213                where
9214                    V: serde::de::MapAccess<'de>,
9215            {
9216                let mut upstream_source_id__ = None;
9217                let mut row_id_index__ = None;
9218                let mut columns__ = None;
9219                let mut info__ = None;
9220                let mut source_name__ = None;
9221                let mut with_properties__ = None;
9222                let mut rate_limit__ = None;
9223                let mut state_table__ = None;
9224                let mut secret_refs__ = None;
9225                while let Some(k) = map_.next_key()? {
9226                    match k {
9227                        GeneratedField::UpstreamSourceId => {
9228                            if upstream_source_id__.is_some() {
9229                                return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
9230                            }
9231                            upstream_source_id__ = 
9232                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9233                            ;
9234                        }
9235                        GeneratedField::RowIdIndex => {
9236                            if row_id_index__.is_some() {
9237                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9238                            }
9239                            row_id_index__ = 
9240                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9241                            ;
9242                        }
9243                        GeneratedField::Columns => {
9244                            if columns__.is_some() {
9245                                return Err(serde::de::Error::duplicate_field("columns"));
9246                            }
9247                            columns__ = Some(map_.next_value()?);
9248                        }
9249                        GeneratedField::Info => {
9250                            if info__.is_some() {
9251                                return Err(serde::de::Error::duplicate_field("info"));
9252                            }
9253                            info__ = map_.next_value()?;
9254                        }
9255                        GeneratedField::SourceName => {
9256                            if source_name__.is_some() {
9257                                return Err(serde::de::Error::duplicate_field("sourceName"));
9258                            }
9259                            source_name__ = Some(map_.next_value()?);
9260                        }
9261                        GeneratedField::WithProperties => {
9262                            if with_properties__.is_some() {
9263                                return Err(serde::de::Error::duplicate_field("withProperties"));
9264                            }
9265                            with_properties__ = Some(
9266                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
9267                            );
9268                        }
9269                        GeneratedField::RateLimit => {
9270                            if rate_limit__.is_some() {
9271                                return Err(serde::de::Error::duplicate_field("rateLimit"));
9272                            }
9273                            rate_limit__ = 
9274                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9275                            ;
9276                        }
9277                        GeneratedField::StateTable => {
9278                            if state_table__.is_some() {
9279                                return Err(serde::de::Error::duplicate_field("stateTable"));
9280                            }
9281                            state_table__ = map_.next_value()?;
9282                        }
9283                        GeneratedField::SecretRefs => {
9284                            if secret_refs__.is_some() {
9285                                return Err(serde::de::Error::duplicate_field("secretRefs"));
9286                            }
9287                            secret_refs__ = Some(
9288                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
9289                            );
9290                        }
9291                    }
9292                }
9293                Ok(SourceBackfillNode {
9294                    upstream_source_id: upstream_source_id__.unwrap_or_default(),
9295                    row_id_index: row_id_index__,
9296                    columns: columns__.unwrap_or_default(),
9297                    info: info__,
9298                    source_name: source_name__.unwrap_or_default(),
9299                    with_properties: with_properties__.unwrap_or_default(),
9300                    rate_limit: rate_limit__,
9301                    state_table: state_table__,
9302                    secret_refs: secret_refs__.unwrap_or_default(),
9303                })
9304            }
9305        }
9306        deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
9307    }
9308}
9309impl serde::Serialize for SourceChangeSplitMutation {
9310    #[allow(deprecated)]
9311    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9312    where
9313        S: serde::Serializer,
9314    {
9315        use serde::ser::SerializeStruct;
9316        let mut len = 0;
9317        if !self.actor_splits.is_empty() {
9318            len += 1;
9319        }
9320        let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
9321        if !self.actor_splits.is_empty() {
9322            struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
9323        }
9324        struct_ser.end()
9325    }
9326}
9327impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
9328    #[allow(deprecated)]
9329    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9330    where
9331        D: serde::Deserializer<'de>,
9332    {
9333        const FIELDS: &[&str] = &[
9334            "actor_splits",
9335            "actorSplits",
9336        ];
9337
9338        #[allow(clippy::enum_variant_names)]
9339        enum GeneratedField {
9340            ActorSplits,
9341        }
9342        impl<'de> serde::Deserialize<'de> for GeneratedField {
9343            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9344            where
9345                D: serde::Deserializer<'de>,
9346            {
9347                struct GeneratedVisitor;
9348
9349                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9350                    type Value = GeneratedField;
9351
9352                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9353                        write!(formatter, "expected one of: {:?}", &FIELDS)
9354                    }
9355
9356                    #[allow(unused_variables)]
9357                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9358                    where
9359                        E: serde::de::Error,
9360                    {
9361                        match value {
9362                            "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
9363                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9364                        }
9365                    }
9366                }
9367                deserializer.deserialize_identifier(GeneratedVisitor)
9368            }
9369        }
9370        struct GeneratedVisitor;
9371        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9372            type Value = SourceChangeSplitMutation;
9373
9374            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9375                formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
9376            }
9377
9378            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
9379                where
9380                    V: serde::de::MapAccess<'de>,
9381            {
9382                let mut actor_splits__ = None;
9383                while let Some(k) = map_.next_key()? {
9384                    match k {
9385                        GeneratedField::ActorSplits => {
9386                            if actor_splits__.is_some() {
9387                                return Err(serde::de::Error::duplicate_field("actorSplits"));
9388                            }
9389                            actor_splits__ = Some(
9390                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9391                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
9392                            );
9393                        }
9394                    }
9395                }
9396                Ok(SourceChangeSplitMutation {
9397                    actor_splits: actor_splits__.unwrap_or_default(),
9398                })
9399            }
9400        }
9401        deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
9402    }
9403}
9404impl serde::Serialize for SourceNode {
9405    #[allow(deprecated)]
9406    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9407    where
9408        S: serde::Serializer,
9409    {
9410        use serde::ser::SerializeStruct;
9411        let mut len = 0;
9412        if self.source_inner.is_some() {
9413            len += 1;
9414        }
9415        let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
9416        if let Some(v) = self.source_inner.as_ref() {
9417            struct_ser.serialize_field("sourceInner", v)?;
9418        }
9419        struct_ser.end()
9420    }
9421}
9422impl<'de> serde::Deserialize<'de> for SourceNode {
9423    #[allow(deprecated)]
9424    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9425    where
9426        D: serde::Deserializer<'de>,
9427    {
9428        const FIELDS: &[&str] = &[
9429            "source_inner",
9430            "sourceInner",
9431        ];
9432
9433        #[allow(clippy::enum_variant_names)]
9434        enum GeneratedField {
9435            SourceInner,
9436        }
9437        impl<'de> serde::Deserialize<'de> for GeneratedField {
9438            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9439            where
9440                D: serde::Deserializer<'de>,
9441            {
9442                struct GeneratedVisitor;
9443
9444                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9445                    type Value = GeneratedField;
9446
9447                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9448                        write!(formatter, "expected one of: {:?}", &FIELDS)
9449                    }
9450
9451                    #[allow(unused_variables)]
9452                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9453                    where
9454                        E: serde::de::Error,
9455                    {
9456                        match value {
9457                            "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
9458                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9459                        }
9460                    }
9461                }
9462                deserializer.deserialize_identifier(GeneratedVisitor)
9463            }
9464        }
9465        struct GeneratedVisitor;
9466        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9467            type Value = SourceNode;
9468
9469            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9470                formatter.write_str("struct stream_plan.SourceNode")
9471            }
9472
9473            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
9474                where
9475                    V: serde::de::MapAccess<'de>,
9476            {
9477                let mut source_inner__ = None;
9478                while let Some(k) = map_.next_key()? {
9479                    match k {
9480                        GeneratedField::SourceInner => {
9481                            if source_inner__.is_some() {
9482                                return Err(serde::de::Error::duplicate_field("sourceInner"));
9483                            }
9484                            source_inner__ = map_.next_value()?;
9485                        }
9486                    }
9487                }
9488                Ok(SourceNode {
9489                    source_inner: source_inner__,
9490                })
9491            }
9492        }
9493        deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
9494    }
9495}
9496impl serde::Serialize for StartFragmentBackfillMutation {
9497    #[allow(deprecated)]
9498    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9499    where
9500        S: serde::Serializer,
9501    {
9502        use serde::ser::SerializeStruct;
9503        let mut len = 0;
9504        if !self.fragment_ids.is_empty() {
9505            len += 1;
9506        }
9507        let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
9508        if !self.fragment_ids.is_empty() {
9509            struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
9510        }
9511        struct_ser.end()
9512    }
9513}
9514impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
9515    #[allow(deprecated)]
9516    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9517    where
9518        D: serde::Deserializer<'de>,
9519    {
9520        const FIELDS: &[&str] = &[
9521            "fragment_ids",
9522            "fragmentIds",
9523        ];
9524
9525        #[allow(clippy::enum_variant_names)]
9526        enum GeneratedField {
9527            FragmentIds,
9528        }
9529        impl<'de> serde::Deserialize<'de> for GeneratedField {
9530            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9531            where
9532                D: serde::Deserializer<'de>,
9533            {
9534                struct GeneratedVisitor;
9535
9536                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9537                    type Value = GeneratedField;
9538
9539                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9540                        write!(formatter, "expected one of: {:?}", &FIELDS)
9541                    }
9542
9543                    #[allow(unused_variables)]
9544                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9545                    where
9546                        E: serde::de::Error,
9547                    {
9548                        match value {
9549                            "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
9550                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9551                        }
9552                    }
9553                }
9554                deserializer.deserialize_identifier(GeneratedVisitor)
9555            }
9556        }
9557        struct GeneratedVisitor;
9558        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9559            type Value = StartFragmentBackfillMutation;
9560
9561            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9562                formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
9563            }
9564
9565            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
9566                where
9567                    V: serde::de::MapAccess<'de>,
9568            {
9569                let mut fragment_ids__ = None;
9570                while let Some(k) = map_.next_key()? {
9571                    match k {
9572                        GeneratedField::FragmentIds => {
9573                            if fragment_ids__.is_some() {
9574                                return Err(serde::de::Error::duplicate_field("fragmentIds"));
9575                            }
9576                            fragment_ids__ = 
9577                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9578                                    .into_iter().map(|x| x.0).collect())
9579                            ;
9580                        }
9581                    }
9582                }
9583                Ok(StartFragmentBackfillMutation {
9584                    fragment_ids: fragment_ids__.unwrap_or_default(),
9585                })
9586            }
9587        }
9588        deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
9589    }
9590}
9591impl serde::Serialize for StopMutation {
9592    #[allow(deprecated)]
9593    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9594    where
9595        S: serde::Serializer,
9596    {
9597        use serde::ser::SerializeStruct;
9598        let mut len = 0;
9599        if !self.actors.is_empty() {
9600            len += 1;
9601        }
9602        let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
9603        if !self.actors.is_empty() {
9604            struct_ser.serialize_field("actors", &self.actors)?;
9605        }
9606        struct_ser.end()
9607    }
9608}
9609impl<'de> serde::Deserialize<'de> for StopMutation {
9610    #[allow(deprecated)]
9611    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9612    where
9613        D: serde::Deserializer<'de>,
9614    {
9615        const FIELDS: &[&str] = &[
9616            "actors",
9617        ];
9618
9619        #[allow(clippy::enum_variant_names)]
9620        enum GeneratedField {
9621            Actors,
9622        }
9623        impl<'de> serde::Deserialize<'de> for GeneratedField {
9624            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9625            where
9626                D: serde::Deserializer<'de>,
9627            {
9628                struct GeneratedVisitor;
9629
9630                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9631                    type Value = GeneratedField;
9632
9633                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9634                        write!(formatter, "expected one of: {:?}", &FIELDS)
9635                    }
9636
9637                    #[allow(unused_variables)]
9638                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9639                    where
9640                        E: serde::de::Error,
9641                    {
9642                        match value {
9643                            "actors" => Ok(GeneratedField::Actors),
9644                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9645                        }
9646                    }
9647                }
9648                deserializer.deserialize_identifier(GeneratedVisitor)
9649            }
9650        }
9651        struct GeneratedVisitor;
9652        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9653            type Value = StopMutation;
9654
9655            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9656                formatter.write_str("struct stream_plan.StopMutation")
9657            }
9658
9659            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
9660                where
9661                    V: serde::de::MapAccess<'de>,
9662            {
9663                let mut actors__ = None;
9664                while let Some(k) = map_.next_key()? {
9665                    match k {
9666                        GeneratedField::Actors => {
9667                            if actors__.is_some() {
9668                                return Err(serde::de::Error::duplicate_field("actors"));
9669                            }
9670                            actors__ = 
9671                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9672                                    .into_iter().map(|x| x.0).collect())
9673                            ;
9674                        }
9675                    }
9676                }
9677                Ok(StopMutation {
9678                    actors: actors__.unwrap_or_default(),
9679                })
9680            }
9681        }
9682        deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
9683    }
9684}
9685impl serde::Serialize for StreamActor {
9686    #[allow(deprecated)]
9687    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9688    where
9689        S: serde::Serializer,
9690    {
9691        use serde::ser::SerializeStruct;
9692        let mut len = 0;
9693        if self.actor_id != 0 {
9694            len += 1;
9695        }
9696        if self.fragment_id != 0 {
9697            len += 1;
9698        }
9699        if !self.dispatcher.is_empty() {
9700            len += 1;
9701        }
9702        if self.vnode_bitmap.is_some() {
9703            len += 1;
9704        }
9705        if !self.mview_definition.is_empty() {
9706            len += 1;
9707        }
9708        if self.expr_context.is_some() {
9709            len += 1;
9710        }
9711        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
9712        if self.actor_id != 0 {
9713            struct_ser.serialize_field("actorId", &self.actor_id)?;
9714        }
9715        if self.fragment_id != 0 {
9716            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
9717        }
9718        if !self.dispatcher.is_empty() {
9719            struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
9720        }
9721        if let Some(v) = self.vnode_bitmap.as_ref() {
9722            struct_ser.serialize_field("vnodeBitmap", v)?;
9723        }
9724        if !self.mview_definition.is_empty() {
9725            struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
9726        }
9727        if let Some(v) = self.expr_context.as_ref() {
9728            struct_ser.serialize_field("exprContext", v)?;
9729        }
9730        struct_ser.end()
9731    }
9732}
9733impl<'de> serde::Deserialize<'de> for StreamActor {
9734    #[allow(deprecated)]
9735    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9736    where
9737        D: serde::Deserializer<'de>,
9738    {
9739        const FIELDS: &[&str] = &[
9740            "actor_id",
9741            "actorId",
9742            "fragment_id",
9743            "fragmentId",
9744            "dispatcher",
9745            "vnode_bitmap",
9746            "vnodeBitmap",
9747            "mview_definition",
9748            "mviewDefinition",
9749            "expr_context",
9750            "exprContext",
9751        ];
9752
9753        #[allow(clippy::enum_variant_names)]
9754        enum GeneratedField {
9755            ActorId,
9756            FragmentId,
9757            Dispatcher,
9758            VnodeBitmap,
9759            MviewDefinition,
9760            ExprContext,
9761        }
9762        impl<'de> serde::Deserialize<'de> for GeneratedField {
9763            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9764            where
9765                D: serde::Deserializer<'de>,
9766            {
9767                struct GeneratedVisitor;
9768
9769                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9770                    type Value = GeneratedField;
9771
9772                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9773                        write!(formatter, "expected one of: {:?}", &FIELDS)
9774                    }
9775
9776                    #[allow(unused_variables)]
9777                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9778                    where
9779                        E: serde::de::Error,
9780                    {
9781                        match value {
9782                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
9783                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
9784                            "dispatcher" => Ok(GeneratedField::Dispatcher),
9785                            "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
9786                            "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
9787                            "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
9788                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9789                        }
9790                    }
9791                }
9792                deserializer.deserialize_identifier(GeneratedVisitor)
9793            }
9794        }
9795        struct GeneratedVisitor;
9796        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9797            type Value = StreamActor;
9798
9799            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9800                formatter.write_str("struct stream_plan.StreamActor")
9801            }
9802
9803            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
9804                where
9805                    V: serde::de::MapAccess<'de>,
9806            {
9807                let mut actor_id__ = None;
9808                let mut fragment_id__ = None;
9809                let mut dispatcher__ = None;
9810                let mut vnode_bitmap__ = None;
9811                let mut mview_definition__ = None;
9812                let mut expr_context__ = None;
9813                while let Some(k) = map_.next_key()? {
9814                    match k {
9815                        GeneratedField::ActorId => {
9816                            if actor_id__.is_some() {
9817                                return Err(serde::de::Error::duplicate_field("actorId"));
9818                            }
9819                            actor_id__ = 
9820                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9821                            ;
9822                        }
9823                        GeneratedField::FragmentId => {
9824                            if fragment_id__.is_some() {
9825                                return Err(serde::de::Error::duplicate_field("fragmentId"));
9826                            }
9827                            fragment_id__ = 
9828                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9829                            ;
9830                        }
9831                        GeneratedField::Dispatcher => {
9832                            if dispatcher__.is_some() {
9833                                return Err(serde::de::Error::duplicate_field("dispatcher"));
9834                            }
9835                            dispatcher__ = Some(map_.next_value()?);
9836                        }
9837                        GeneratedField::VnodeBitmap => {
9838                            if vnode_bitmap__.is_some() {
9839                                return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
9840                            }
9841                            vnode_bitmap__ = map_.next_value()?;
9842                        }
9843                        GeneratedField::MviewDefinition => {
9844                            if mview_definition__.is_some() {
9845                                return Err(serde::de::Error::duplicate_field("mviewDefinition"));
9846                            }
9847                            mview_definition__ = Some(map_.next_value()?);
9848                        }
9849                        GeneratedField::ExprContext => {
9850                            if expr_context__.is_some() {
9851                                return Err(serde::de::Error::duplicate_field("exprContext"));
9852                            }
9853                            expr_context__ = map_.next_value()?;
9854                        }
9855                    }
9856                }
9857                Ok(StreamActor {
9858                    actor_id: actor_id__.unwrap_or_default(),
9859                    fragment_id: fragment_id__.unwrap_or_default(),
9860                    dispatcher: dispatcher__.unwrap_or_default(),
9861                    vnode_bitmap: vnode_bitmap__,
9862                    mview_definition: mview_definition__.unwrap_or_default(),
9863                    expr_context: expr_context__,
9864                })
9865            }
9866        }
9867        deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
9868    }
9869}
9870impl serde::Serialize for StreamCdcScanNode {
9871    #[allow(deprecated)]
9872    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9873    where
9874        S: serde::Serializer,
9875    {
9876        use serde::ser::SerializeStruct;
9877        let mut len = 0;
9878        if self.table_id != 0 {
9879            len += 1;
9880        }
9881        if !self.upstream_column_ids.is_empty() {
9882            len += 1;
9883        }
9884        if !self.output_indices.is_empty() {
9885            len += 1;
9886        }
9887        if self.state_table.is_some() {
9888            len += 1;
9889        }
9890        if self.cdc_table_desc.is_some() {
9891            len += 1;
9892        }
9893        if self.rate_limit.is_some() {
9894            len += 1;
9895        }
9896        if self.disable_backfill {
9897            len += 1;
9898        }
9899        if self.options.is_some() {
9900            len += 1;
9901        }
9902        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
9903        if self.table_id != 0 {
9904            struct_ser.serialize_field("tableId", &self.table_id)?;
9905        }
9906        if !self.upstream_column_ids.is_empty() {
9907            struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
9908        }
9909        if !self.output_indices.is_empty() {
9910            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
9911        }
9912        if let Some(v) = self.state_table.as_ref() {
9913            struct_ser.serialize_field("stateTable", v)?;
9914        }
9915        if let Some(v) = self.cdc_table_desc.as_ref() {
9916            struct_ser.serialize_field("cdcTableDesc", v)?;
9917        }
9918        if let Some(v) = self.rate_limit.as_ref() {
9919            struct_ser.serialize_field("rateLimit", v)?;
9920        }
9921        if self.disable_backfill {
9922            struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
9923        }
9924        if let Some(v) = self.options.as_ref() {
9925            struct_ser.serialize_field("options", v)?;
9926        }
9927        struct_ser.end()
9928    }
9929}
9930impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
9931    #[allow(deprecated)]
9932    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9933    where
9934        D: serde::Deserializer<'de>,
9935    {
9936        const FIELDS: &[&str] = &[
9937            "table_id",
9938            "tableId",
9939            "upstream_column_ids",
9940            "upstreamColumnIds",
9941            "output_indices",
9942            "outputIndices",
9943            "state_table",
9944            "stateTable",
9945            "cdc_table_desc",
9946            "cdcTableDesc",
9947            "rate_limit",
9948            "rateLimit",
9949            "disable_backfill",
9950            "disableBackfill",
9951            "options",
9952        ];
9953
9954        #[allow(clippy::enum_variant_names)]
9955        enum GeneratedField {
9956            TableId,
9957            UpstreamColumnIds,
9958            OutputIndices,
9959            StateTable,
9960            CdcTableDesc,
9961            RateLimit,
9962            DisableBackfill,
9963            Options,
9964        }
9965        impl<'de> serde::Deserialize<'de> for GeneratedField {
9966            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9967            where
9968                D: serde::Deserializer<'de>,
9969            {
9970                struct GeneratedVisitor;
9971
9972                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9973                    type Value = GeneratedField;
9974
9975                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9976                        write!(formatter, "expected one of: {:?}", &FIELDS)
9977                    }
9978
9979                    #[allow(unused_variables)]
9980                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9981                    where
9982                        E: serde::de::Error,
9983                    {
9984                        match value {
9985                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
9986                            "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
9987                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
9988                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9989                            "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
9990                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9991                            "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
9992                            "options" => Ok(GeneratedField::Options),
9993                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9994                        }
9995                    }
9996                }
9997                deserializer.deserialize_identifier(GeneratedVisitor)
9998            }
9999        }
10000        struct GeneratedVisitor;
10001        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10002            type Value = StreamCdcScanNode;
10003
10004            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10005                formatter.write_str("struct stream_plan.StreamCdcScanNode")
10006            }
10007
10008            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
10009                where
10010                    V: serde::de::MapAccess<'de>,
10011            {
10012                let mut table_id__ = None;
10013                let mut upstream_column_ids__ = None;
10014                let mut output_indices__ = None;
10015                let mut state_table__ = None;
10016                let mut cdc_table_desc__ = None;
10017                let mut rate_limit__ = None;
10018                let mut disable_backfill__ = None;
10019                let mut options__ = None;
10020                while let Some(k) = map_.next_key()? {
10021                    match k {
10022                        GeneratedField::TableId => {
10023                            if table_id__.is_some() {
10024                                return Err(serde::de::Error::duplicate_field("tableId"));
10025                            }
10026                            table_id__ = 
10027                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10028                            ;
10029                        }
10030                        GeneratedField::UpstreamColumnIds => {
10031                            if upstream_column_ids__.is_some() {
10032                                return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
10033                            }
10034                            upstream_column_ids__ = 
10035                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10036                                    .into_iter().map(|x| x.0).collect())
10037                            ;
10038                        }
10039                        GeneratedField::OutputIndices => {
10040                            if output_indices__.is_some() {
10041                                return Err(serde::de::Error::duplicate_field("outputIndices"));
10042                            }
10043                            output_indices__ = 
10044                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10045                                    .into_iter().map(|x| x.0).collect())
10046                            ;
10047                        }
10048                        GeneratedField::StateTable => {
10049                            if state_table__.is_some() {
10050                                return Err(serde::de::Error::duplicate_field("stateTable"));
10051                            }
10052                            state_table__ = map_.next_value()?;
10053                        }
10054                        GeneratedField::CdcTableDesc => {
10055                            if cdc_table_desc__.is_some() {
10056                                return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
10057                            }
10058                            cdc_table_desc__ = map_.next_value()?;
10059                        }
10060                        GeneratedField::RateLimit => {
10061                            if rate_limit__.is_some() {
10062                                return Err(serde::de::Error::duplicate_field("rateLimit"));
10063                            }
10064                            rate_limit__ = 
10065                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10066                            ;
10067                        }
10068                        GeneratedField::DisableBackfill => {
10069                            if disable_backfill__.is_some() {
10070                                return Err(serde::de::Error::duplicate_field("disableBackfill"));
10071                            }
10072                            disable_backfill__ = Some(map_.next_value()?);
10073                        }
10074                        GeneratedField::Options => {
10075                            if options__.is_some() {
10076                                return Err(serde::de::Error::duplicate_field("options"));
10077                            }
10078                            options__ = map_.next_value()?;
10079                        }
10080                    }
10081                }
10082                Ok(StreamCdcScanNode {
10083                    table_id: table_id__.unwrap_or_default(),
10084                    upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
10085                    output_indices: output_indices__.unwrap_or_default(),
10086                    state_table: state_table__,
10087                    cdc_table_desc: cdc_table_desc__,
10088                    rate_limit: rate_limit__,
10089                    disable_backfill: disable_backfill__.unwrap_or_default(),
10090                    options: options__,
10091                })
10092            }
10093        }
10094        deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
10095    }
10096}
10097impl serde::Serialize for StreamCdcScanOptions {
10098    #[allow(deprecated)]
10099    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10100    where
10101        S: serde::Serializer,
10102    {
10103        use serde::ser::SerializeStruct;
10104        let mut len = 0;
10105        if self.disable_backfill {
10106            len += 1;
10107        }
10108        if self.snapshot_barrier_interval != 0 {
10109            len += 1;
10110        }
10111        if self.snapshot_batch_size != 0 {
10112            len += 1;
10113        }
10114        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
10115        if self.disable_backfill {
10116            struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
10117        }
10118        if self.snapshot_barrier_interval != 0 {
10119            struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
10120        }
10121        if self.snapshot_batch_size != 0 {
10122            struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
10123        }
10124        struct_ser.end()
10125    }
10126}
10127impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
10128    #[allow(deprecated)]
10129    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10130    where
10131        D: serde::Deserializer<'de>,
10132    {
10133        const FIELDS: &[&str] = &[
10134            "disable_backfill",
10135            "disableBackfill",
10136            "snapshot_barrier_interval",
10137            "snapshotBarrierInterval",
10138            "snapshot_batch_size",
10139            "snapshotBatchSize",
10140        ];
10141
10142        #[allow(clippy::enum_variant_names)]
10143        enum GeneratedField {
10144            DisableBackfill,
10145            SnapshotBarrierInterval,
10146            SnapshotBatchSize,
10147        }
10148        impl<'de> serde::Deserialize<'de> for GeneratedField {
10149            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10150            where
10151                D: serde::Deserializer<'de>,
10152            {
10153                struct GeneratedVisitor;
10154
10155                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10156                    type Value = GeneratedField;
10157
10158                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10159                        write!(formatter, "expected one of: {:?}", &FIELDS)
10160                    }
10161
10162                    #[allow(unused_variables)]
10163                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10164                    where
10165                        E: serde::de::Error,
10166                    {
10167                        match value {
10168                            "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
10169                            "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
10170                            "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
10171                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10172                        }
10173                    }
10174                }
10175                deserializer.deserialize_identifier(GeneratedVisitor)
10176            }
10177        }
10178        struct GeneratedVisitor;
10179        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10180            type Value = StreamCdcScanOptions;
10181
10182            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10183                formatter.write_str("struct stream_plan.StreamCdcScanOptions")
10184            }
10185
10186            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
10187                where
10188                    V: serde::de::MapAccess<'de>,
10189            {
10190                let mut disable_backfill__ = None;
10191                let mut snapshot_barrier_interval__ = None;
10192                let mut snapshot_batch_size__ = None;
10193                while let Some(k) = map_.next_key()? {
10194                    match k {
10195                        GeneratedField::DisableBackfill => {
10196                            if disable_backfill__.is_some() {
10197                                return Err(serde::de::Error::duplicate_field("disableBackfill"));
10198                            }
10199                            disable_backfill__ = Some(map_.next_value()?);
10200                        }
10201                        GeneratedField::SnapshotBarrierInterval => {
10202                            if snapshot_barrier_interval__.is_some() {
10203                                return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
10204                            }
10205                            snapshot_barrier_interval__ = 
10206                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10207                            ;
10208                        }
10209                        GeneratedField::SnapshotBatchSize => {
10210                            if snapshot_batch_size__.is_some() {
10211                                return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
10212                            }
10213                            snapshot_batch_size__ = 
10214                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10215                            ;
10216                        }
10217                    }
10218                }
10219                Ok(StreamCdcScanOptions {
10220                    disable_backfill: disable_backfill__.unwrap_or_default(),
10221                    snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
10222                    snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
10223                })
10224            }
10225        }
10226        deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
10227    }
10228}
10229impl serde::Serialize for StreamContext {
10230    #[allow(deprecated)]
10231    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10232    where
10233        S: serde::Serializer,
10234    {
10235        use serde::ser::SerializeStruct;
10236        let mut len = 0;
10237        if !self.timezone.is_empty() {
10238            len += 1;
10239        }
10240        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
10241        if !self.timezone.is_empty() {
10242            struct_ser.serialize_field("timezone", &self.timezone)?;
10243        }
10244        struct_ser.end()
10245    }
10246}
10247impl<'de> serde::Deserialize<'de> for StreamContext {
10248    #[allow(deprecated)]
10249    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10250    where
10251        D: serde::Deserializer<'de>,
10252    {
10253        const FIELDS: &[&str] = &[
10254            "timezone",
10255        ];
10256
10257        #[allow(clippy::enum_variant_names)]
10258        enum GeneratedField {
10259            Timezone,
10260        }
10261        impl<'de> serde::Deserialize<'de> for GeneratedField {
10262            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10263            where
10264                D: serde::Deserializer<'de>,
10265            {
10266                struct GeneratedVisitor;
10267
10268                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10269                    type Value = GeneratedField;
10270
10271                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10272                        write!(formatter, "expected one of: {:?}", &FIELDS)
10273                    }
10274
10275                    #[allow(unused_variables)]
10276                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10277                    where
10278                        E: serde::de::Error,
10279                    {
10280                        match value {
10281                            "timezone" => Ok(GeneratedField::Timezone),
10282                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10283                        }
10284                    }
10285                }
10286                deserializer.deserialize_identifier(GeneratedVisitor)
10287            }
10288        }
10289        struct GeneratedVisitor;
10290        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10291            type Value = StreamContext;
10292
10293            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10294                formatter.write_str("struct stream_plan.StreamContext")
10295            }
10296
10297            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
10298                where
10299                    V: serde::de::MapAccess<'de>,
10300            {
10301                let mut timezone__ = None;
10302                while let Some(k) = map_.next_key()? {
10303                    match k {
10304                        GeneratedField::Timezone => {
10305                            if timezone__.is_some() {
10306                                return Err(serde::de::Error::duplicate_field("timezone"));
10307                            }
10308                            timezone__ = Some(map_.next_value()?);
10309                        }
10310                    }
10311                }
10312                Ok(StreamContext {
10313                    timezone: timezone__.unwrap_or_default(),
10314                })
10315            }
10316        }
10317        deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
10318    }
10319}
10320impl serde::Serialize for StreamFragmentGraph {
10321    #[allow(deprecated)]
10322    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10323    where
10324        S: serde::Serializer,
10325    {
10326        use serde::ser::SerializeStruct;
10327        let mut len = 0;
10328        if !self.fragments.is_empty() {
10329            len += 1;
10330        }
10331        if !self.edges.is_empty() {
10332            len += 1;
10333        }
10334        if !self.dependent_table_ids.is_empty() {
10335            len += 1;
10336        }
10337        if self.table_ids_cnt != 0 {
10338            len += 1;
10339        }
10340        if self.ctx.is_some() {
10341            len += 1;
10342        }
10343        if self.parallelism.is_some() {
10344            len += 1;
10345        }
10346        if self.max_parallelism != 0 {
10347            len += 1;
10348        }
10349        if self.backfill_order.is_some() {
10350            len += 1;
10351        }
10352        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
10353        if !self.fragments.is_empty() {
10354            struct_ser.serialize_field("fragments", &self.fragments)?;
10355        }
10356        if !self.edges.is_empty() {
10357            struct_ser.serialize_field("edges", &self.edges)?;
10358        }
10359        if !self.dependent_table_ids.is_empty() {
10360            struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
10361        }
10362        if self.table_ids_cnt != 0 {
10363            struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
10364        }
10365        if let Some(v) = self.ctx.as_ref() {
10366            struct_ser.serialize_field("ctx", v)?;
10367        }
10368        if let Some(v) = self.parallelism.as_ref() {
10369            struct_ser.serialize_field("parallelism", v)?;
10370        }
10371        if self.max_parallelism != 0 {
10372            struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10373        }
10374        if let Some(v) = self.backfill_order.as_ref() {
10375            struct_ser.serialize_field("backfillOrder", v)?;
10376        }
10377        struct_ser.end()
10378    }
10379}
10380impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
10381    #[allow(deprecated)]
10382    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10383    where
10384        D: serde::Deserializer<'de>,
10385    {
10386        const FIELDS: &[&str] = &[
10387            "fragments",
10388            "edges",
10389            "dependent_table_ids",
10390            "dependentTableIds",
10391            "table_ids_cnt",
10392            "tableIdsCnt",
10393            "ctx",
10394            "parallelism",
10395            "max_parallelism",
10396            "maxParallelism",
10397            "backfill_order",
10398            "backfillOrder",
10399        ];
10400
10401        #[allow(clippy::enum_variant_names)]
10402        enum GeneratedField {
10403            Fragments,
10404            Edges,
10405            DependentTableIds,
10406            TableIdsCnt,
10407            Ctx,
10408            Parallelism,
10409            MaxParallelism,
10410            BackfillOrder,
10411        }
10412        impl<'de> serde::Deserialize<'de> for GeneratedField {
10413            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10414            where
10415                D: serde::Deserializer<'de>,
10416            {
10417                struct GeneratedVisitor;
10418
10419                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10420                    type Value = GeneratedField;
10421
10422                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10423                        write!(formatter, "expected one of: {:?}", &FIELDS)
10424                    }
10425
10426                    #[allow(unused_variables)]
10427                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10428                    where
10429                        E: serde::de::Error,
10430                    {
10431                        match value {
10432                            "fragments" => Ok(GeneratedField::Fragments),
10433                            "edges" => Ok(GeneratedField::Edges),
10434                            "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
10435                            "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
10436                            "ctx" => Ok(GeneratedField::Ctx),
10437                            "parallelism" => Ok(GeneratedField::Parallelism),
10438                            "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
10439                            "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
10440                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10441                        }
10442                    }
10443                }
10444                deserializer.deserialize_identifier(GeneratedVisitor)
10445            }
10446        }
10447        struct GeneratedVisitor;
10448        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10449            type Value = StreamFragmentGraph;
10450
10451            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10452                formatter.write_str("struct stream_plan.StreamFragmentGraph")
10453            }
10454
10455            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
10456                where
10457                    V: serde::de::MapAccess<'de>,
10458            {
10459                let mut fragments__ = None;
10460                let mut edges__ = None;
10461                let mut dependent_table_ids__ = None;
10462                let mut table_ids_cnt__ = None;
10463                let mut ctx__ = None;
10464                let mut parallelism__ = None;
10465                let mut max_parallelism__ = None;
10466                let mut backfill_order__ = None;
10467                while let Some(k) = map_.next_key()? {
10468                    match k {
10469                        GeneratedField::Fragments => {
10470                            if fragments__.is_some() {
10471                                return Err(serde::de::Error::duplicate_field("fragments"));
10472                            }
10473                            fragments__ = Some(
10474                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10475                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
10476                            );
10477                        }
10478                        GeneratedField::Edges => {
10479                            if edges__.is_some() {
10480                                return Err(serde::de::Error::duplicate_field("edges"));
10481                            }
10482                            edges__ = Some(map_.next_value()?);
10483                        }
10484                        GeneratedField::DependentTableIds => {
10485                            if dependent_table_ids__.is_some() {
10486                                return Err(serde::de::Error::duplicate_field("dependentTableIds"));
10487                            }
10488                            dependent_table_ids__ = 
10489                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10490                                    .into_iter().map(|x| x.0).collect())
10491                            ;
10492                        }
10493                        GeneratedField::TableIdsCnt => {
10494                            if table_ids_cnt__.is_some() {
10495                                return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
10496                            }
10497                            table_ids_cnt__ = 
10498                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10499                            ;
10500                        }
10501                        GeneratedField::Ctx => {
10502                            if ctx__.is_some() {
10503                                return Err(serde::de::Error::duplicate_field("ctx"));
10504                            }
10505                            ctx__ = map_.next_value()?;
10506                        }
10507                        GeneratedField::Parallelism => {
10508                            if parallelism__.is_some() {
10509                                return Err(serde::de::Error::duplicate_field("parallelism"));
10510                            }
10511                            parallelism__ = map_.next_value()?;
10512                        }
10513                        GeneratedField::MaxParallelism => {
10514                            if max_parallelism__.is_some() {
10515                                return Err(serde::de::Error::duplicate_field("maxParallelism"));
10516                            }
10517                            max_parallelism__ = 
10518                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10519                            ;
10520                        }
10521                        GeneratedField::BackfillOrder => {
10522                            if backfill_order__.is_some() {
10523                                return Err(serde::de::Error::duplicate_field("backfillOrder"));
10524                            }
10525                            backfill_order__ = map_.next_value()?;
10526                        }
10527                    }
10528                }
10529                Ok(StreamFragmentGraph {
10530                    fragments: fragments__.unwrap_or_default(),
10531                    edges: edges__.unwrap_or_default(),
10532                    dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
10533                    table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
10534                    ctx: ctx__,
10535                    parallelism: parallelism__,
10536                    max_parallelism: max_parallelism__.unwrap_or_default(),
10537                    backfill_order: backfill_order__,
10538                })
10539            }
10540        }
10541        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
10542    }
10543}
10544impl serde::Serialize for stream_fragment_graph::Parallelism {
10545    #[allow(deprecated)]
10546    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10547    where
10548        S: serde::Serializer,
10549    {
10550        use serde::ser::SerializeStruct;
10551        let mut len = 0;
10552        if self.parallelism != 0 {
10553            len += 1;
10554        }
10555        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
10556        if self.parallelism != 0 {
10557            #[allow(clippy::needless_borrow)]
10558            #[allow(clippy::needless_borrows_for_generic_args)]
10559            struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
10560        }
10561        struct_ser.end()
10562    }
10563}
10564impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
10565    #[allow(deprecated)]
10566    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10567    where
10568        D: serde::Deserializer<'de>,
10569    {
10570        const FIELDS: &[&str] = &[
10571            "parallelism",
10572        ];
10573
10574        #[allow(clippy::enum_variant_names)]
10575        enum GeneratedField {
10576            Parallelism,
10577        }
10578        impl<'de> serde::Deserialize<'de> for GeneratedField {
10579            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10580            where
10581                D: serde::Deserializer<'de>,
10582            {
10583                struct GeneratedVisitor;
10584
10585                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10586                    type Value = GeneratedField;
10587
10588                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10589                        write!(formatter, "expected one of: {:?}", &FIELDS)
10590                    }
10591
10592                    #[allow(unused_variables)]
10593                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10594                    where
10595                        E: serde::de::Error,
10596                    {
10597                        match value {
10598                            "parallelism" => Ok(GeneratedField::Parallelism),
10599                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10600                        }
10601                    }
10602                }
10603                deserializer.deserialize_identifier(GeneratedVisitor)
10604            }
10605        }
10606        struct GeneratedVisitor;
10607        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10608            type Value = stream_fragment_graph::Parallelism;
10609
10610            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10611                formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
10612            }
10613
10614            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
10615                where
10616                    V: serde::de::MapAccess<'de>,
10617            {
10618                let mut parallelism__ = None;
10619                while let Some(k) = map_.next_key()? {
10620                    match k {
10621                        GeneratedField::Parallelism => {
10622                            if parallelism__.is_some() {
10623                                return Err(serde::de::Error::duplicate_field("parallelism"));
10624                            }
10625                            parallelism__ = 
10626                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10627                            ;
10628                        }
10629                    }
10630                }
10631                Ok(stream_fragment_graph::Parallelism {
10632                    parallelism: parallelism__.unwrap_or_default(),
10633                })
10634            }
10635        }
10636        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
10637    }
10638}
10639impl serde::Serialize for stream_fragment_graph::StreamFragment {
10640    #[allow(deprecated)]
10641    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10642    where
10643        S: serde::Serializer,
10644    {
10645        use serde::ser::SerializeStruct;
10646        let mut len = 0;
10647        if self.fragment_id != 0 {
10648            len += 1;
10649        }
10650        if self.node.is_some() {
10651            len += 1;
10652        }
10653        if self.fragment_type_mask != 0 {
10654            len += 1;
10655        }
10656        if self.requires_singleton {
10657            len += 1;
10658        }
10659        if self.table_ids_cnt != 0 {
10660            len += 1;
10661        }
10662        if !self.upstream_table_ids.is_empty() {
10663            len += 1;
10664        }
10665        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
10666        if self.fragment_id != 0 {
10667            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10668        }
10669        if let Some(v) = self.node.as_ref() {
10670            struct_ser.serialize_field("node", v)?;
10671        }
10672        if self.fragment_type_mask != 0 {
10673            struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
10674        }
10675        if self.requires_singleton {
10676            struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
10677        }
10678        if self.table_ids_cnt != 0 {
10679            struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
10680        }
10681        if !self.upstream_table_ids.is_empty() {
10682            struct_ser.serialize_field("upstreamTableIds", &self.upstream_table_ids)?;
10683        }
10684        struct_ser.end()
10685    }
10686}
10687impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
10688    #[allow(deprecated)]
10689    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10690    where
10691        D: serde::Deserializer<'de>,
10692    {
10693        const FIELDS: &[&str] = &[
10694            "fragment_id",
10695            "fragmentId",
10696            "node",
10697            "fragment_type_mask",
10698            "fragmentTypeMask",
10699            "requires_singleton",
10700            "requiresSingleton",
10701            "table_ids_cnt",
10702            "tableIdsCnt",
10703            "upstream_table_ids",
10704            "upstreamTableIds",
10705        ];
10706
10707        #[allow(clippy::enum_variant_names)]
10708        enum GeneratedField {
10709            FragmentId,
10710            Node,
10711            FragmentTypeMask,
10712            RequiresSingleton,
10713            TableIdsCnt,
10714            UpstreamTableIds,
10715        }
10716        impl<'de> serde::Deserialize<'de> for GeneratedField {
10717            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10718            where
10719                D: serde::Deserializer<'de>,
10720            {
10721                struct GeneratedVisitor;
10722
10723                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10724                    type Value = GeneratedField;
10725
10726                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10727                        write!(formatter, "expected one of: {:?}", &FIELDS)
10728                    }
10729
10730                    #[allow(unused_variables)]
10731                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10732                    where
10733                        E: serde::de::Error,
10734                    {
10735                        match value {
10736                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10737                            "node" => Ok(GeneratedField::Node),
10738                            "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
10739                            "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
10740                            "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
10741                            "upstreamTableIds" | "upstream_table_ids" => Ok(GeneratedField::UpstreamTableIds),
10742                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10743                        }
10744                    }
10745                }
10746                deserializer.deserialize_identifier(GeneratedVisitor)
10747            }
10748        }
10749        struct GeneratedVisitor;
10750        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10751            type Value = stream_fragment_graph::StreamFragment;
10752
10753            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10754                formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
10755            }
10756
10757            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
10758                where
10759                    V: serde::de::MapAccess<'de>,
10760            {
10761                let mut fragment_id__ = None;
10762                let mut node__ = None;
10763                let mut fragment_type_mask__ = None;
10764                let mut requires_singleton__ = None;
10765                let mut table_ids_cnt__ = None;
10766                let mut upstream_table_ids__ = None;
10767                while let Some(k) = map_.next_key()? {
10768                    match k {
10769                        GeneratedField::FragmentId => {
10770                            if fragment_id__.is_some() {
10771                                return Err(serde::de::Error::duplicate_field("fragmentId"));
10772                            }
10773                            fragment_id__ = 
10774                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10775                            ;
10776                        }
10777                        GeneratedField::Node => {
10778                            if node__.is_some() {
10779                                return Err(serde::de::Error::duplicate_field("node"));
10780                            }
10781                            node__ = map_.next_value()?;
10782                        }
10783                        GeneratedField::FragmentTypeMask => {
10784                            if fragment_type_mask__.is_some() {
10785                                return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
10786                            }
10787                            fragment_type_mask__ = 
10788                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10789                            ;
10790                        }
10791                        GeneratedField::RequiresSingleton => {
10792                            if requires_singleton__.is_some() {
10793                                return Err(serde::de::Error::duplicate_field("requiresSingleton"));
10794                            }
10795                            requires_singleton__ = Some(map_.next_value()?);
10796                        }
10797                        GeneratedField::TableIdsCnt => {
10798                            if table_ids_cnt__.is_some() {
10799                                return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
10800                            }
10801                            table_ids_cnt__ = 
10802                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10803                            ;
10804                        }
10805                        GeneratedField::UpstreamTableIds => {
10806                            if upstream_table_ids__.is_some() {
10807                                return Err(serde::de::Error::duplicate_field("upstreamTableIds"));
10808                            }
10809                            upstream_table_ids__ = 
10810                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10811                                    .into_iter().map(|x| x.0).collect())
10812                            ;
10813                        }
10814                    }
10815                }
10816                Ok(stream_fragment_graph::StreamFragment {
10817                    fragment_id: fragment_id__.unwrap_or_default(),
10818                    node: node__,
10819                    fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
10820                    requires_singleton: requires_singleton__.unwrap_or_default(),
10821                    table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
10822                    upstream_table_ids: upstream_table_ids__.unwrap_or_default(),
10823                })
10824            }
10825        }
10826        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
10827    }
10828}
10829impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
10830    #[allow(deprecated)]
10831    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10832    where
10833        S: serde::Serializer,
10834    {
10835        use serde::ser::SerializeStruct;
10836        let mut len = 0;
10837        if self.dispatch_strategy.is_some() {
10838            len += 1;
10839        }
10840        if self.link_id != 0 {
10841            len += 1;
10842        }
10843        if self.upstream_id != 0 {
10844            len += 1;
10845        }
10846        if self.downstream_id != 0 {
10847            len += 1;
10848        }
10849        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
10850        if let Some(v) = self.dispatch_strategy.as_ref() {
10851            struct_ser.serialize_field("dispatchStrategy", v)?;
10852        }
10853        if self.link_id != 0 {
10854            #[allow(clippy::needless_borrow)]
10855            #[allow(clippy::needless_borrows_for_generic_args)]
10856            struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
10857        }
10858        if self.upstream_id != 0 {
10859            struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
10860        }
10861        if self.downstream_id != 0 {
10862            struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
10863        }
10864        struct_ser.end()
10865    }
10866}
10867impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
10868    #[allow(deprecated)]
10869    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10870    where
10871        D: serde::Deserializer<'de>,
10872    {
10873        const FIELDS: &[&str] = &[
10874            "dispatch_strategy",
10875            "dispatchStrategy",
10876            "link_id",
10877            "linkId",
10878            "upstream_id",
10879            "upstreamId",
10880            "downstream_id",
10881            "downstreamId",
10882        ];
10883
10884        #[allow(clippy::enum_variant_names)]
10885        enum GeneratedField {
10886            DispatchStrategy,
10887            LinkId,
10888            UpstreamId,
10889            DownstreamId,
10890        }
10891        impl<'de> serde::Deserialize<'de> for GeneratedField {
10892            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10893            where
10894                D: serde::Deserializer<'de>,
10895            {
10896                struct GeneratedVisitor;
10897
10898                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10899                    type Value = GeneratedField;
10900
10901                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10902                        write!(formatter, "expected one of: {:?}", &FIELDS)
10903                    }
10904
10905                    #[allow(unused_variables)]
10906                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10907                    where
10908                        E: serde::de::Error,
10909                    {
10910                        match value {
10911                            "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
10912                            "linkId" | "link_id" => Ok(GeneratedField::LinkId),
10913                            "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
10914                            "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
10915                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10916                        }
10917                    }
10918                }
10919                deserializer.deserialize_identifier(GeneratedVisitor)
10920            }
10921        }
10922        struct GeneratedVisitor;
10923        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10924            type Value = stream_fragment_graph::StreamFragmentEdge;
10925
10926            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10927                formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
10928            }
10929
10930            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
10931                where
10932                    V: serde::de::MapAccess<'de>,
10933            {
10934                let mut dispatch_strategy__ = None;
10935                let mut link_id__ = None;
10936                let mut upstream_id__ = None;
10937                let mut downstream_id__ = None;
10938                while let Some(k) = map_.next_key()? {
10939                    match k {
10940                        GeneratedField::DispatchStrategy => {
10941                            if dispatch_strategy__.is_some() {
10942                                return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
10943                            }
10944                            dispatch_strategy__ = map_.next_value()?;
10945                        }
10946                        GeneratedField::LinkId => {
10947                            if link_id__.is_some() {
10948                                return Err(serde::de::Error::duplicate_field("linkId"));
10949                            }
10950                            link_id__ = 
10951                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10952                            ;
10953                        }
10954                        GeneratedField::UpstreamId => {
10955                            if upstream_id__.is_some() {
10956                                return Err(serde::de::Error::duplicate_field("upstreamId"));
10957                            }
10958                            upstream_id__ = 
10959                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10960                            ;
10961                        }
10962                        GeneratedField::DownstreamId => {
10963                            if downstream_id__.is_some() {
10964                                return Err(serde::de::Error::duplicate_field("downstreamId"));
10965                            }
10966                            downstream_id__ = 
10967                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10968                            ;
10969                        }
10970                    }
10971                }
10972                Ok(stream_fragment_graph::StreamFragmentEdge {
10973                    dispatch_strategy: dispatch_strategy__,
10974                    link_id: link_id__.unwrap_or_default(),
10975                    upstream_id: upstream_id__.unwrap_or_default(),
10976                    downstream_id: downstream_id__.unwrap_or_default(),
10977                })
10978            }
10979        }
10980        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
10981    }
10982}
10983impl serde::Serialize for StreamFsFetch {
10984    #[allow(deprecated)]
10985    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10986    where
10987        S: serde::Serializer,
10988    {
10989        use serde::ser::SerializeStruct;
10990        let mut len = 0;
10991        if self.source_id != 0 {
10992            len += 1;
10993        }
10994        if self.state_table.is_some() {
10995            len += 1;
10996        }
10997        if self.row_id_index.is_some() {
10998            len += 1;
10999        }
11000        if !self.columns.is_empty() {
11001            len += 1;
11002        }
11003        if !self.with_properties.is_empty() {
11004            len += 1;
11005        }
11006        if self.info.is_some() {
11007            len += 1;
11008        }
11009        if !self.source_name.is_empty() {
11010            len += 1;
11011        }
11012        if self.rate_limit.is_some() {
11013            len += 1;
11014        }
11015        if !self.secret_refs.is_empty() {
11016            len += 1;
11017        }
11018        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
11019        if self.source_id != 0 {
11020            struct_ser.serialize_field("sourceId", &self.source_id)?;
11021        }
11022        if let Some(v) = self.state_table.as_ref() {
11023            struct_ser.serialize_field("stateTable", v)?;
11024        }
11025        if let Some(v) = self.row_id_index.as_ref() {
11026            struct_ser.serialize_field("rowIdIndex", v)?;
11027        }
11028        if !self.columns.is_empty() {
11029            struct_ser.serialize_field("columns", &self.columns)?;
11030        }
11031        if !self.with_properties.is_empty() {
11032            struct_ser.serialize_field("withProperties", &self.with_properties)?;
11033        }
11034        if let Some(v) = self.info.as_ref() {
11035            struct_ser.serialize_field("info", v)?;
11036        }
11037        if !self.source_name.is_empty() {
11038            struct_ser.serialize_field("sourceName", &self.source_name)?;
11039        }
11040        if let Some(v) = self.rate_limit.as_ref() {
11041            struct_ser.serialize_field("rateLimit", v)?;
11042        }
11043        if !self.secret_refs.is_empty() {
11044            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
11045        }
11046        struct_ser.end()
11047    }
11048}
11049impl<'de> serde::Deserialize<'de> for StreamFsFetch {
11050    #[allow(deprecated)]
11051    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11052    where
11053        D: serde::Deserializer<'de>,
11054    {
11055        const FIELDS: &[&str] = &[
11056            "source_id",
11057            "sourceId",
11058            "state_table",
11059            "stateTable",
11060            "row_id_index",
11061            "rowIdIndex",
11062            "columns",
11063            "with_properties",
11064            "withProperties",
11065            "info",
11066            "source_name",
11067            "sourceName",
11068            "rate_limit",
11069            "rateLimit",
11070            "secret_refs",
11071            "secretRefs",
11072        ];
11073
11074        #[allow(clippy::enum_variant_names)]
11075        enum GeneratedField {
11076            SourceId,
11077            StateTable,
11078            RowIdIndex,
11079            Columns,
11080            WithProperties,
11081            Info,
11082            SourceName,
11083            RateLimit,
11084            SecretRefs,
11085        }
11086        impl<'de> serde::Deserialize<'de> for GeneratedField {
11087            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11088            where
11089                D: serde::Deserializer<'de>,
11090            {
11091                struct GeneratedVisitor;
11092
11093                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11094                    type Value = GeneratedField;
11095
11096                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11097                        write!(formatter, "expected one of: {:?}", &FIELDS)
11098                    }
11099
11100                    #[allow(unused_variables)]
11101                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11102                    where
11103                        E: serde::de::Error,
11104                    {
11105                        match value {
11106                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
11107                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11108                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
11109                            "columns" => Ok(GeneratedField::Columns),
11110                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
11111                            "info" => Ok(GeneratedField::Info),
11112                            "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
11113                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11114                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
11115                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11116                        }
11117                    }
11118                }
11119                deserializer.deserialize_identifier(GeneratedVisitor)
11120            }
11121        }
11122        struct GeneratedVisitor;
11123        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11124            type Value = StreamFsFetch;
11125
11126            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11127                formatter.write_str("struct stream_plan.StreamFsFetch")
11128            }
11129
11130            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
11131                where
11132                    V: serde::de::MapAccess<'de>,
11133            {
11134                let mut source_id__ = None;
11135                let mut state_table__ = None;
11136                let mut row_id_index__ = None;
11137                let mut columns__ = None;
11138                let mut with_properties__ = None;
11139                let mut info__ = None;
11140                let mut source_name__ = None;
11141                let mut rate_limit__ = None;
11142                let mut secret_refs__ = None;
11143                while let Some(k) = map_.next_key()? {
11144                    match k {
11145                        GeneratedField::SourceId => {
11146                            if source_id__.is_some() {
11147                                return Err(serde::de::Error::duplicate_field("sourceId"));
11148                            }
11149                            source_id__ = 
11150                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11151                            ;
11152                        }
11153                        GeneratedField::StateTable => {
11154                            if state_table__.is_some() {
11155                                return Err(serde::de::Error::duplicate_field("stateTable"));
11156                            }
11157                            state_table__ = map_.next_value()?;
11158                        }
11159                        GeneratedField::RowIdIndex => {
11160                            if row_id_index__.is_some() {
11161                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
11162                            }
11163                            row_id_index__ = 
11164                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11165                            ;
11166                        }
11167                        GeneratedField::Columns => {
11168                            if columns__.is_some() {
11169                                return Err(serde::de::Error::duplicate_field("columns"));
11170                            }
11171                            columns__ = Some(map_.next_value()?);
11172                        }
11173                        GeneratedField::WithProperties => {
11174                            if with_properties__.is_some() {
11175                                return Err(serde::de::Error::duplicate_field("withProperties"));
11176                            }
11177                            with_properties__ = Some(
11178                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
11179                            );
11180                        }
11181                        GeneratedField::Info => {
11182                            if info__.is_some() {
11183                                return Err(serde::de::Error::duplicate_field("info"));
11184                            }
11185                            info__ = map_.next_value()?;
11186                        }
11187                        GeneratedField::SourceName => {
11188                            if source_name__.is_some() {
11189                                return Err(serde::de::Error::duplicate_field("sourceName"));
11190                            }
11191                            source_name__ = Some(map_.next_value()?);
11192                        }
11193                        GeneratedField::RateLimit => {
11194                            if rate_limit__.is_some() {
11195                                return Err(serde::de::Error::duplicate_field("rateLimit"));
11196                            }
11197                            rate_limit__ = 
11198                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11199                            ;
11200                        }
11201                        GeneratedField::SecretRefs => {
11202                            if secret_refs__.is_some() {
11203                                return Err(serde::de::Error::duplicate_field("secretRefs"));
11204                            }
11205                            secret_refs__ = Some(
11206                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
11207                            );
11208                        }
11209                    }
11210                }
11211                Ok(StreamFsFetch {
11212                    source_id: source_id__.unwrap_or_default(),
11213                    state_table: state_table__,
11214                    row_id_index: row_id_index__,
11215                    columns: columns__.unwrap_or_default(),
11216                    with_properties: with_properties__.unwrap_or_default(),
11217                    info: info__,
11218                    source_name: source_name__.unwrap_or_default(),
11219                    rate_limit: rate_limit__,
11220                    secret_refs: secret_refs__.unwrap_or_default(),
11221                })
11222            }
11223        }
11224        deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
11225    }
11226}
11227impl serde::Serialize for StreamFsFetchNode {
11228    #[allow(deprecated)]
11229    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11230    where
11231        S: serde::Serializer,
11232    {
11233        use serde::ser::SerializeStruct;
11234        let mut len = 0;
11235        if self.node_inner.is_some() {
11236            len += 1;
11237        }
11238        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
11239        if let Some(v) = self.node_inner.as_ref() {
11240            struct_ser.serialize_field("nodeInner", v)?;
11241        }
11242        struct_ser.end()
11243    }
11244}
11245impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
11246    #[allow(deprecated)]
11247    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11248    where
11249        D: serde::Deserializer<'de>,
11250    {
11251        const FIELDS: &[&str] = &[
11252            "node_inner",
11253            "nodeInner",
11254        ];
11255
11256        #[allow(clippy::enum_variant_names)]
11257        enum GeneratedField {
11258            NodeInner,
11259        }
11260        impl<'de> serde::Deserialize<'de> for GeneratedField {
11261            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11262            where
11263                D: serde::Deserializer<'de>,
11264            {
11265                struct GeneratedVisitor;
11266
11267                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11268                    type Value = GeneratedField;
11269
11270                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11271                        write!(formatter, "expected one of: {:?}", &FIELDS)
11272                    }
11273
11274                    #[allow(unused_variables)]
11275                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11276                    where
11277                        E: serde::de::Error,
11278                    {
11279                        match value {
11280                            "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
11281                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11282                        }
11283                    }
11284                }
11285                deserializer.deserialize_identifier(GeneratedVisitor)
11286            }
11287        }
11288        struct GeneratedVisitor;
11289        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11290            type Value = StreamFsFetchNode;
11291
11292            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11293                formatter.write_str("struct stream_plan.StreamFsFetchNode")
11294            }
11295
11296            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
11297                where
11298                    V: serde::de::MapAccess<'de>,
11299            {
11300                let mut node_inner__ = None;
11301                while let Some(k) = map_.next_key()? {
11302                    match k {
11303                        GeneratedField::NodeInner => {
11304                            if node_inner__.is_some() {
11305                                return Err(serde::de::Error::duplicate_field("nodeInner"));
11306                            }
11307                            node_inner__ = map_.next_value()?;
11308                        }
11309                    }
11310                }
11311                Ok(StreamFsFetchNode {
11312                    node_inner: node_inner__,
11313                })
11314            }
11315        }
11316        deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
11317    }
11318}
11319impl serde::Serialize for StreamMessage {
11320    #[allow(deprecated)]
11321    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11322    where
11323        S: serde::Serializer,
11324    {
11325        use serde::ser::SerializeStruct;
11326        let mut len = 0;
11327        if self.stream_message.is_some() {
11328            len += 1;
11329        }
11330        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
11331        if let Some(v) = self.stream_message.as_ref() {
11332            match v {
11333                stream_message::StreamMessage::StreamChunk(v) => {
11334                    struct_ser.serialize_field("streamChunk", v)?;
11335                }
11336                stream_message::StreamMessage::Barrier(v) => {
11337                    struct_ser.serialize_field("barrier", v)?;
11338                }
11339                stream_message::StreamMessage::Watermark(v) => {
11340                    struct_ser.serialize_field("watermark", v)?;
11341                }
11342            }
11343        }
11344        struct_ser.end()
11345    }
11346}
11347impl<'de> serde::Deserialize<'de> for StreamMessage {
11348    #[allow(deprecated)]
11349    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11350    where
11351        D: serde::Deserializer<'de>,
11352    {
11353        const FIELDS: &[&str] = &[
11354            "stream_chunk",
11355            "streamChunk",
11356            "barrier",
11357            "watermark",
11358        ];
11359
11360        #[allow(clippy::enum_variant_names)]
11361        enum GeneratedField {
11362            StreamChunk,
11363            Barrier,
11364            Watermark,
11365        }
11366        impl<'de> serde::Deserialize<'de> for GeneratedField {
11367            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11368            where
11369                D: serde::Deserializer<'de>,
11370            {
11371                struct GeneratedVisitor;
11372
11373                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11374                    type Value = GeneratedField;
11375
11376                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11377                        write!(formatter, "expected one of: {:?}", &FIELDS)
11378                    }
11379
11380                    #[allow(unused_variables)]
11381                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11382                    where
11383                        E: serde::de::Error,
11384                    {
11385                        match value {
11386                            "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
11387                            "barrier" => Ok(GeneratedField::Barrier),
11388                            "watermark" => Ok(GeneratedField::Watermark),
11389                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11390                        }
11391                    }
11392                }
11393                deserializer.deserialize_identifier(GeneratedVisitor)
11394            }
11395        }
11396        struct GeneratedVisitor;
11397        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11398            type Value = StreamMessage;
11399
11400            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11401                formatter.write_str("struct stream_plan.StreamMessage")
11402            }
11403
11404            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
11405                where
11406                    V: serde::de::MapAccess<'de>,
11407            {
11408                let mut stream_message__ = None;
11409                while let Some(k) = map_.next_key()? {
11410                    match k {
11411                        GeneratedField::StreamChunk => {
11412                            if stream_message__.is_some() {
11413                                return Err(serde::de::Error::duplicate_field("streamChunk"));
11414                            }
11415                            stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
11416;
11417                        }
11418                        GeneratedField::Barrier => {
11419                            if stream_message__.is_some() {
11420                                return Err(serde::de::Error::duplicate_field("barrier"));
11421                            }
11422                            stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
11423;
11424                        }
11425                        GeneratedField::Watermark => {
11426                            if stream_message__.is_some() {
11427                                return Err(serde::de::Error::duplicate_field("watermark"));
11428                            }
11429                            stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
11430;
11431                        }
11432                    }
11433                }
11434                Ok(StreamMessage {
11435                    stream_message: stream_message__,
11436                })
11437            }
11438        }
11439        deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
11440    }
11441}
11442impl serde::Serialize for StreamMessageBatch {
11443    #[allow(deprecated)]
11444    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11445    where
11446        S: serde::Serializer,
11447    {
11448        use serde::ser::SerializeStruct;
11449        let mut len = 0;
11450        if self.stream_message_batch.is_some() {
11451            len += 1;
11452        }
11453        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
11454        if let Some(v) = self.stream_message_batch.as_ref() {
11455            match v {
11456                stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
11457                    struct_ser.serialize_field("streamChunk", v)?;
11458                }
11459                stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
11460                    struct_ser.serialize_field("barrierBatch", v)?;
11461                }
11462                stream_message_batch::StreamMessageBatch::Watermark(v) => {
11463                    struct_ser.serialize_field("watermark", v)?;
11464                }
11465            }
11466        }
11467        struct_ser.end()
11468    }
11469}
11470impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
11471    #[allow(deprecated)]
11472    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11473    where
11474        D: serde::Deserializer<'de>,
11475    {
11476        const FIELDS: &[&str] = &[
11477            "stream_chunk",
11478            "streamChunk",
11479            "barrier_batch",
11480            "barrierBatch",
11481            "watermark",
11482        ];
11483
11484        #[allow(clippy::enum_variant_names)]
11485        enum GeneratedField {
11486            StreamChunk,
11487            BarrierBatch,
11488            Watermark,
11489        }
11490        impl<'de> serde::Deserialize<'de> for GeneratedField {
11491            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11492            where
11493                D: serde::Deserializer<'de>,
11494            {
11495                struct GeneratedVisitor;
11496
11497                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11498                    type Value = GeneratedField;
11499
11500                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11501                        write!(formatter, "expected one of: {:?}", &FIELDS)
11502                    }
11503
11504                    #[allow(unused_variables)]
11505                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11506                    where
11507                        E: serde::de::Error,
11508                    {
11509                        match value {
11510                            "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
11511                            "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
11512                            "watermark" => Ok(GeneratedField::Watermark),
11513                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11514                        }
11515                    }
11516                }
11517                deserializer.deserialize_identifier(GeneratedVisitor)
11518            }
11519        }
11520        struct GeneratedVisitor;
11521        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11522            type Value = StreamMessageBatch;
11523
11524            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11525                formatter.write_str("struct stream_plan.StreamMessageBatch")
11526            }
11527
11528            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
11529                where
11530                    V: serde::de::MapAccess<'de>,
11531            {
11532                let mut stream_message_batch__ = None;
11533                while let Some(k) = map_.next_key()? {
11534                    match k {
11535                        GeneratedField::StreamChunk => {
11536                            if stream_message_batch__.is_some() {
11537                                return Err(serde::de::Error::duplicate_field("streamChunk"));
11538                            }
11539                            stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
11540;
11541                        }
11542                        GeneratedField::BarrierBatch => {
11543                            if stream_message_batch__.is_some() {
11544                                return Err(serde::de::Error::duplicate_field("barrierBatch"));
11545                            }
11546                            stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
11547;
11548                        }
11549                        GeneratedField::Watermark => {
11550                            if stream_message_batch__.is_some() {
11551                                return Err(serde::de::Error::duplicate_field("watermark"));
11552                            }
11553                            stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
11554;
11555                        }
11556                    }
11557                }
11558                Ok(StreamMessageBatch {
11559                    stream_message_batch: stream_message_batch__,
11560                })
11561            }
11562        }
11563        deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
11564    }
11565}
11566impl serde::Serialize for stream_message_batch::BarrierBatch {
11567    #[allow(deprecated)]
11568    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11569    where
11570        S: serde::Serializer,
11571    {
11572        use serde::ser::SerializeStruct;
11573        let mut len = 0;
11574        if !self.barriers.is_empty() {
11575            len += 1;
11576        }
11577        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
11578        if !self.barriers.is_empty() {
11579            struct_ser.serialize_field("barriers", &self.barriers)?;
11580        }
11581        struct_ser.end()
11582    }
11583}
11584impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
11585    #[allow(deprecated)]
11586    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11587    where
11588        D: serde::Deserializer<'de>,
11589    {
11590        const FIELDS: &[&str] = &[
11591            "barriers",
11592        ];
11593
11594        #[allow(clippy::enum_variant_names)]
11595        enum GeneratedField {
11596            Barriers,
11597        }
11598        impl<'de> serde::Deserialize<'de> for GeneratedField {
11599            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11600            where
11601                D: serde::Deserializer<'de>,
11602            {
11603                struct GeneratedVisitor;
11604
11605                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11606                    type Value = GeneratedField;
11607
11608                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11609                        write!(formatter, "expected one of: {:?}", &FIELDS)
11610                    }
11611
11612                    #[allow(unused_variables)]
11613                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11614                    where
11615                        E: serde::de::Error,
11616                    {
11617                        match value {
11618                            "barriers" => Ok(GeneratedField::Barriers),
11619                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11620                        }
11621                    }
11622                }
11623                deserializer.deserialize_identifier(GeneratedVisitor)
11624            }
11625        }
11626        struct GeneratedVisitor;
11627        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11628            type Value = stream_message_batch::BarrierBatch;
11629
11630            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11631                formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
11632            }
11633
11634            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
11635                where
11636                    V: serde::de::MapAccess<'de>,
11637            {
11638                let mut barriers__ = None;
11639                while let Some(k) = map_.next_key()? {
11640                    match k {
11641                        GeneratedField::Barriers => {
11642                            if barriers__.is_some() {
11643                                return Err(serde::de::Error::duplicate_field("barriers"));
11644                            }
11645                            barriers__ = Some(map_.next_value()?);
11646                        }
11647                    }
11648                }
11649                Ok(stream_message_batch::BarrierBatch {
11650                    barriers: barriers__.unwrap_or_default(),
11651                })
11652            }
11653        }
11654        deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
11655    }
11656}
11657impl serde::Serialize for StreamNode {
11658    #[allow(deprecated)]
11659    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11660    where
11661        S: serde::Serializer,
11662    {
11663        use serde::ser::SerializeStruct;
11664        let mut len = 0;
11665        if self.operator_id != 0 {
11666            len += 1;
11667        }
11668        if !self.input.is_empty() {
11669            len += 1;
11670        }
11671        if !self.stream_key.is_empty() {
11672            len += 1;
11673        }
11674        if self.append_only {
11675            len += 1;
11676        }
11677        if !self.identity.is_empty() {
11678            len += 1;
11679        }
11680        if !self.fields.is_empty() {
11681            len += 1;
11682        }
11683        if self.node_body.is_some() {
11684            len += 1;
11685        }
11686        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
11687        if self.operator_id != 0 {
11688            #[allow(clippy::needless_borrow)]
11689            #[allow(clippy::needless_borrows_for_generic_args)]
11690            struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
11691        }
11692        if !self.input.is_empty() {
11693            struct_ser.serialize_field("input", &self.input)?;
11694        }
11695        if !self.stream_key.is_empty() {
11696            struct_ser.serialize_field("streamKey", &self.stream_key)?;
11697        }
11698        if self.append_only {
11699            struct_ser.serialize_field("appendOnly", &self.append_only)?;
11700        }
11701        if !self.identity.is_empty() {
11702            struct_ser.serialize_field("identity", &self.identity)?;
11703        }
11704        if !self.fields.is_empty() {
11705            struct_ser.serialize_field("fields", &self.fields)?;
11706        }
11707        if let Some(v) = self.node_body.as_ref() {
11708            match v {
11709                stream_node::NodeBody::Source(v) => {
11710                    struct_ser.serialize_field("source", v)?;
11711                }
11712                stream_node::NodeBody::Project(v) => {
11713                    struct_ser.serialize_field("project", v)?;
11714                }
11715                stream_node::NodeBody::Filter(v) => {
11716                    struct_ser.serialize_field("filter", v)?;
11717                }
11718                stream_node::NodeBody::Materialize(v) => {
11719                    struct_ser.serialize_field("materialize", v)?;
11720                }
11721                stream_node::NodeBody::StatelessSimpleAgg(v) => {
11722                    struct_ser.serialize_field("statelessSimpleAgg", v)?;
11723                }
11724                stream_node::NodeBody::SimpleAgg(v) => {
11725                    struct_ser.serialize_field("simpleAgg", v)?;
11726                }
11727                stream_node::NodeBody::HashAgg(v) => {
11728                    struct_ser.serialize_field("hashAgg", v)?;
11729                }
11730                stream_node::NodeBody::AppendOnlyTopN(v) => {
11731                    struct_ser.serialize_field("appendOnlyTopN", v)?;
11732                }
11733                stream_node::NodeBody::HashJoin(v) => {
11734                    struct_ser.serialize_field("hashJoin", v)?;
11735                }
11736                stream_node::NodeBody::TopN(v) => {
11737                    struct_ser.serialize_field("topN", v)?;
11738                }
11739                stream_node::NodeBody::HopWindow(v) => {
11740                    struct_ser.serialize_field("hopWindow", v)?;
11741                }
11742                stream_node::NodeBody::Merge(v) => {
11743                    struct_ser.serialize_field("merge", v)?;
11744                }
11745                stream_node::NodeBody::Exchange(v) => {
11746                    struct_ser.serialize_field("exchange", v)?;
11747                }
11748                stream_node::NodeBody::StreamScan(v) => {
11749                    struct_ser.serialize_field("streamScan", v)?;
11750                }
11751                stream_node::NodeBody::BatchPlan(v) => {
11752                    struct_ser.serialize_field("batchPlan", v)?;
11753                }
11754                stream_node::NodeBody::Lookup(v) => {
11755                    struct_ser.serialize_field("lookup", v)?;
11756                }
11757                stream_node::NodeBody::Arrange(v) => {
11758                    struct_ser.serialize_field("arrange", v)?;
11759                }
11760                stream_node::NodeBody::LookupUnion(v) => {
11761                    struct_ser.serialize_field("lookupUnion", v)?;
11762                }
11763                stream_node::NodeBody::Union(v) => {
11764                    struct_ser.serialize_field("union", v)?;
11765                }
11766                stream_node::NodeBody::DeltaIndexJoin(v) => {
11767                    struct_ser.serialize_field("deltaIndexJoin", v)?;
11768                }
11769                stream_node::NodeBody::Sink(v) => {
11770                    struct_ser.serialize_field("sink", v)?;
11771                }
11772                stream_node::NodeBody::Expand(v) => {
11773                    struct_ser.serialize_field("expand", v)?;
11774                }
11775                stream_node::NodeBody::DynamicFilter(v) => {
11776                    struct_ser.serialize_field("dynamicFilter", v)?;
11777                }
11778                stream_node::NodeBody::ProjectSet(v) => {
11779                    struct_ser.serialize_field("projectSet", v)?;
11780                }
11781                stream_node::NodeBody::GroupTopN(v) => {
11782                    struct_ser.serialize_field("groupTopN", v)?;
11783                }
11784                stream_node::NodeBody::Sort(v) => {
11785                    struct_ser.serialize_field("sort", v)?;
11786                }
11787                stream_node::NodeBody::WatermarkFilter(v) => {
11788                    struct_ser.serialize_field("watermarkFilter", v)?;
11789                }
11790                stream_node::NodeBody::Dml(v) => {
11791                    struct_ser.serialize_field("dml", v)?;
11792                }
11793                stream_node::NodeBody::RowIdGen(v) => {
11794                    struct_ser.serialize_field("rowIdGen", v)?;
11795                }
11796                stream_node::NodeBody::Now(v) => {
11797                    struct_ser.serialize_field("now", v)?;
11798                }
11799                stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
11800                    struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
11801                }
11802                stream_node::NodeBody::TemporalJoin(v) => {
11803                    struct_ser.serialize_field("temporalJoin", v)?;
11804                }
11805                stream_node::NodeBody::BarrierRecv(v) => {
11806                    struct_ser.serialize_field("barrierRecv", v)?;
11807                }
11808                stream_node::NodeBody::Values(v) => {
11809                    struct_ser.serialize_field("values", v)?;
11810                }
11811                stream_node::NodeBody::AppendOnlyDedup(v) => {
11812                    struct_ser.serialize_field("appendOnlyDedup", v)?;
11813                }
11814                stream_node::NodeBody::NoOp(v) => {
11815                    struct_ser.serialize_field("noOp", v)?;
11816                }
11817                stream_node::NodeBody::EowcOverWindow(v) => {
11818                    struct_ser.serialize_field("eowcOverWindow", v)?;
11819                }
11820                stream_node::NodeBody::OverWindow(v) => {
11821                    struct_ser.serialize_field("overWindow", v)?;
11822                }
11823                stream_node::NodeBody::StreamFsFetch(v) => {
11824                    struct_ser.serialize_field("streamFsFetch", v)?;
11825                }
11826                stream_node::NodeBody::StreamCdcScan(v) => {
11827                    struct_ser.serialize_field("streamCdcScan", v)?;
11828                }
11829                stream_node::NodeBody::CdcFilter(v) => {
11830                    struct_ser.serialize_field("cdcFilter", v)?;
11831                }
11832                stream_node::NodeBody::SourceBackfill(v) => {
11833                    struct_ser.serialize_field("sourceBackfill", v)?;
11834                }
11835                stream_node::NodeBody::Changelog(v) => {
11836                    struct_ser.serialize_field("changelog", v)?;
11837                }
11838                stream_node::NodeBody::LocalApproxPercentile(v) => {
11839                    struct_ser.serialize_field("localApproxPercentile", v)?;
11840                }
11841                stream_node::NodeBody::GlobalApproxPercentile(v) => {
11842                    struct_ser.serialize_field("globalApproxPercentile", v)?;
11843                }
11844                stream_node::NodeBody::RowMerge(v) => {
11845                    struct_ser.serialize_field("rowMerge", v)?;
11846                }
11847                stream_node::NodeBody::AsOfJoin(v) => {
11848                    struct_ser.serialize_field("asOfJoin", v)?;
11849                }
11850                stream_node::NodeBody::SyncLogStore(v) => {
11851                    struct_ser.serialize_field("syncLogStore", v)?;
11852                }
11853                stream_node::NodeBody::MaterializedExprs(v) => {
11854                    struct_ser.serialize_field("materializedExprs", v)?;
11855                }
11856            }
11857        }
11858        struct_ser.end()
11859    }
11860}
11861impl<'de> serde::Deserialize<'de> for StreamNode {
11862    #[allow(deprecated)]
11863    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11864    where
11865        D: serde::Deserializer<'de>,
11866    {
11867        const FIELDS: &[&str] = &[
11868            "operator_id",
11869            "operatorId",
11870            "input",
11871            "stream_key",
11872            "streamKey",
11873            "append_only",
11874            "appendOnly",
11875            "identity",
11876            "fields",
11877            "source",
11878            "project",
11879            "filter",
11880            "materialize",
11881            "stateless_simple_agg",
11882            "statelessSimpleAgg",
11883            "simple_agg",
11884            "simpleAgg",
11885            "hash_agg",
11886            "hashAgg",
11887            "append_only_top_n",
11888            "appendOnlyTopN",
11889            "hash_join",
11890            "hashJoin",
11891            "top_n",
11892            "topN",
11893            "hop_window",
11894            "hopWindow",
11895            "merge",
11896            "exchange",
11897            "stream_scan",
11898            "streamScan",
11899            "batch_plan",
11900            "batchPlan",
11901            "lookup",
11902            "arrange",
11903            "lookup_union",
11904            "lookupUnion",
11905            "union",
11906            "delta_index_join",
11907            "deltaIndexJoin",
11908            "sink",
11909            "expand",
11910            "dynamic_filter",
11911            "dynamicFilter",
11912            "project_set",
11913            "projectSet",
11914            "group_top_n",
11915            "groupTopN",
11916            "sort",
11917            "watermark_filter",
11918            "watermarkFilter",
11919            "dml",
11920            "row_id_gen",
11921            "rowIdGen",
11922            "now",
11923            "append_only_group_top_n",
11924            "appendOnlyGroupTopN",
11925            "temporal_join",
11926            "temporalJoin",
11927            "barrier_recv",
11928            "barrierRecv",
11929            "values",
11930            "append_only_dedup",
11931            "appendOnlyDedup",
11932            "no_op",
11933            "noOp",
11934            "eowc_over_window",
11935            "eowcOverWindow",
11936            "over_window",
11937            "overWindow",
11938            "stream_fs_fetch",
11939            "streamFsFetch",
11940            "stream_cdc_scan",
11941            "streamCdcScan",
11942            "cdc_filter",
11943            "cdcFilter",
11944            "source_backfill",
11945            "sourceBackfill",
11946            "changelog",
11947            "local_approx_percentile",
11948            "localApproxPercentile",
11949            "global_approx_percentile",
11950            "globalApproxPercentile",
11951            "row_merge",
11952            "rowMerge",
11953            "as_of_join",
11954            "asOfJoin",
11955            "sync_log_store",
11956            "syncLogStore",
11957            "materialized_exprs",
11958            "materializedExprs",
11959        ];
11960
11961        #[allow(clippy::enum_variant_names)]
11962        enum GeneratedField {
11963            OperatorId,
11964            Input,
11965            StreamKey,
11966            AppendOnly,
11967            Identity,
11968            Fields,
11969            Source,
11970            Project,
11971            Filter,
11972            Materialize,
11973            StatelessSimpleAgg,
11974            SimpleAgg,
11975            HashAgg,
11976            AppendOnlyTopN,
11977            HashJoin,
11978            TopN,
11979            HopWindow,
11980            Merge,
11981            Exchange,
11982            StreamScan,
11983            BatchPlan,
11984            Lookup,
11985            Arrange,
11986            LookupUnion,
11987            Union,
11988            DeltaIndexJoin,
11989            Sink,
11990            Expand,
11991            DynamicFilter,
11992            ProjectSet,
11993            GroupTopN,
11994            Sort,
11995            WatermarkFilter,
11996            Dml,
11997            RowIdGen,
11998            Now,
11999            AppendOnlyGroupTopN,
12000            TemporalJoin,
12001            BarrierRecv,
12002            Values,
12003            AppendOnlyDedup,
12004            NoOp,
12005            EowcOverWindow,
12006            OverWindow,
12007            StreamFsFetch,
12008            StreamCdcScan,
12009            CdcFilter,
12010            SourceBackfill,
12011            Changelog,
12012            LocalApproxPercentile,
12013            GlobalApproxPercentile,
12014            RowMerge,
12015            AsOfJoin,
12016            SyncLogStore,
12017            MaterializedExprs,
12018        }
12019        impl<'de> serde::Deserialize<'de> for GeneratedField {
12020            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12021            where
12022                D: serde::Deserializer<'de>,
12023            {
12024                struct GeneratedVisitor;
12025
12026                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12027                    type Value = GeneratedField;
12028
12029                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12030                        write!(formatter, "expected one of: {:?}", &FIELDS)
12031                    }
12032
12033                    #[allow(unused_variables)]
12034                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12035                    where
12036                        E: serde::de::Error,
12037                    {
12038                        match value {
12039                            "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
12040                            "input" => Ok(GeneratedField::Input),
12041                            "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
12042                            "appendOnly" | "append_only" => Ok(GeneratedField::AppendOnly),
12043                            "identity" => Ok(GeneratedField::Identity),
12044                            "fields" => Ok(GeneratedField::Fields),
12045                            "source" => Ok(GeneratedField::Source),
12046                            "project" => Ok(GeneratedField::Project),
12047                            "filter" => Ok(GeneratedField::Filter),
12048                            "materialize" => Ok(GeneratedField::Materialize),
12049                            "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
12050                            "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
12051                            "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
12052                            "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
12053                            "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
12054                            "topN" | "top_n" => Ok(GeneratedField::TopN),
12055                            "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
12056                            "merge" => Ok(GeneratedField::Merge),
12057                            "exchange" => Ok(GeneratedField::Exchange),
12058                            "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
12059                            "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
12060                            "lookup" => Ok(GeneratedField::Lookup),
12061                            "arrange" => Ok(GeneratedField::Arrange),
12062                            "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
12063                            "union" => Ok(GeneratedField::Union),
12064                            "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
12065                            "sink" => Ok(GeneratedField::Sink),
12066                            "expand" => Ok(GeneratedField::Expand),
12067                            "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
12068                            "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
12069                            "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
12070                            "sort" => Ok(GeneratedField::Sort),
12071                            "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
12072                            "dml" => Ok(GeneratedField::Dml),
12073                            "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
12074                            "now" => Ok(GeneratedField::Now),
12075                            "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
12076                            "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
12077                            "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
12078                            "values" => Ok(GeneratedField::Values),
12079                            "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
12080                            "noOp" | "no_op" => Ok(GeneratedField::NoOp),
12081                            "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
12082                            "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
12083                            "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
12084                            "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
12085                            "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
12086                            "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
12087                            "changelog" => Ok(GeneratedField::Changelog),
12088                            "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
12089                            "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
12090                            "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
12091                            "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
12092                            "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
12093                            "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
12094                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12095                        }
12096                    }
12097                }
12098                deserializer.deserialize_identifier(GeneratedVisitor)
12099            }
12100        }
12101        struct GeneratedVisitor;
12102        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12103            type Value = StreamNode;
12104
12105            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12106                formatter.write_str("struct stream_plan.StreamNode")
12107            }
12108
12109            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
12110                where
12111                    V: serde::de::MapAccess<'de>,
12112            {
12113                let mut operator_id__ = None;
12114                let mut input__ = None;
12115                let mut stream_key__ = None;
12116                let mut append_only__ = None;
12117                let mut identity__ = None;
12118                let mut fields__ = None;
12119                let mut node_body__ = None;
12120                while let Some(k) = map_.next_key()? {
12121                    match k {
12122                        GeneratedField::OperatorId => {
12123                            if operator_id__.is_some() {
12124                                return Err(serde::de::Error::duplicate_field("operatorId"));
12125                            }
12126                            operator_id__ = 
12127                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12128                            ;
12129                        }
12130                        GeneratedField::Input => {
12131                            if input__.is_some() {
12132                                return Err(serde::de::Error::duplicate_field("input"));
12133                            }
12134                            input__ = Some(map_.next_value()?);
12135                        }
12136                        GeneratedField::StreamKey => {
12137                            if stream_key__.is_some() {
12138                                return Err(serde::de::Error::duplicate_field("streamKey"));
12139                            }
12140                            stream_key__ = 
12141                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12142                                    .into_iter().map(|x| x.0).collect())
12143                            ;
12144                        }
12145                        GeneratedField::AppendOnly => {
12146                            if append_only__.is_some() {
12147                                return Err(serde::de::Error::duplicate_field("appendOnly"));
12148                            }
12149                            append_only__ = Some(map_.next_value()?);
12150                        }
12151                        GeneratedField::Identity => {
12152                            if identity__.is_some() {
12153                                return Err(serde::de::Error::duplicate_field("identity"));
12154                            }
12155                            identity__ = Some(map_.next_value()?);
12156                        }
12157                        GeneratedField::Fields => {
12158                            if fields__.is_some() {
12159                                return Err(serde::de::Error::duplicate_field("fields"));
12160                            }
12161                            fields__ = Some(map_.next_value()?);
12162                        }
12163                        GeneratedField::Source => {
12164                            if node_body__.is_some() {
12165                                return Err(serde::de::Error::duplicate_field("source"));
12166                            }
12167                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
12168;
12169                        }
12170                        GeneratedField::Project => {
12171                            if node_body__.is_some() {
12172                                return Err(serde::de::Error::duplicate_field("project"));
12173                            }
12174                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
12175;
12176                        }
12177                        GeneratedField::Filter => {
12178                            if node_body__.is_some() {
12179                                return Err(serde::de::Error::duplicate_field("filter"));
12180                            }
12181                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
12182;
12183                        }
12184                        GeneratedField::Materialize => {
12185                            if node_body__.is_some() {
12186                                return Err(serde::de::Error::duplicate_field("materialize"));
12187                            }
12188                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
12189;
12190                        }
12191                        GeneratedField::StatelessSimpleAgg => {
12192                            if node_body__.is_some() {
12193                                return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
12194                            }
12195                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
12196;
12197                        }
12198                        GeneratedField::SimpleAgg => {
12199                            if node_body__.is_some() {
12200                                return Err(serde::de::Error::duplicate_field("simpleAgg"));
12201                            }
12202                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
12203;
12204                        }
12205                        GeneratedField::HashAgg => {
12206                            if node_body__.is_some() {
12207                                return Err(serde::de::Error::duplicate_field("hashAgg"));
12208                            }
12209                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
12210;
12211                        }
12212                        GeneratedField::AppendOnlyTopN => {
12213                            if node_body__.is_some() {
12214                                return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
12215                            }
12216                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
12217;
12218                        }
12219                        GeneratedField::HashJoin => {
12220                            if node_body__.is_some() {
12221                                return Err(serde::de::Error::duplicate_field("hashJoin"));
12222                            }
12223                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
12224;
12225                        }
12226                        GeneratedField::TopN => {
12227                            if node_body__.is_some() {
12228                                return Err(serde::de::Error::duplicate_field("topN"));
12229                            }
12230                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
12231;
12232                        }
12233                        GeneratedField::HopWindow => {
12234                            if node_body__.is_some() {
12235                                return Err(serde::de::Error::duplicate_field("hopWindow"));
12236                            }
12237                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
12238;
12239                        }
12240                        GeneratedField::Merge => {
12241                            if node_body__.is_some() {
12242                                return Err(serde::de::Error::duplicate_field("merge"));
12243                            }
12244                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
12245;
12246                        }
12247                        GeneratedField::Exchange => {
12248                            if node_body__.is_some() {
12249                                return Err(serde::de::Error::duplicate_field("exchange"));
12250                            }
12251                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
12252;
12253                        }
12254                        GeneratedField::StreamScan => {
12255                            if node_body__.is_some() {
12256                                return Err(serde::de::Error::duplicate_field("streamScan"));
12257                            }
12258                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
12259;
12260                        }
12261                        GeneratedField::BatchPlan => {
12262                            if node_body__.is_some() {
12263                                return Err(serde::de::Error::duplicate_field("batchPlan"));
12264                            }
12265                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
12266;
12267                        }
12268                        GeneratedField::Lookup => {
12269                            if node_body__.is_some() {
12270                                return Err(serde::de::Error::duplicate_field("lookup"));
12271                            }
12272                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
12273;
12274                        }
12275                        GeneratedField::Arrange => {
12276                            if node_body__.is_some() {
12277                                return Err(serde::de::Error::duplicate_field("arrange"));
12278                            }
12279                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
12280;
12281                        }
12282                        GeneratedField::LookupUnion => {
12283                            if node_body__.is_some() {
12284                                return Err(serde::de::Error::duplicate_field("lookupUnion"));
12285                            }
12286                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
12287;
12288                        }
12289                        GeneratedField::Union => {
12290                            if node_body__.is_some() {
12291                                return Err(serde::de::Error::duplicate_field("union"));
12292                            }
12293                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
12294;
12295                        }
12296                        GeneratedField::DeltaIndexJoin => {
12297                            if node_body__.is_some() {
12298                                return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
12299                            }
12300                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
12301;
12302                        }
12303                        GeneratedField::Sink => {
12304                            if node_body__.is_some() {
12305                                return Err(serde::de::Error::duplicate_field("sink"));
12306                            }
12307                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
12308;
12309                        }
12310                        GeneratedField::Expand => {
12311                            if node_body__.is_some() {
12312                                return Err(serde::de::Error::duplicate_field("expand"));
12313                            }
12314                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
12315;
12316                        }
12317                        GeneratedField::DynamicFilter => {
12318                            if node_body__.is_some() {
12319                                return Err(serde::de::Error::duplicate_field("dynamicFilter"));
12320                            }
12321                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
12322;
12323                        }
12324                        GeneratedField::ProjectSet => {
12325                            if node_body__.is_some() {
12326                                return Err(serde::de::Error::duplicate_field("projectSet"));
12327                            }
12328                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
12329;
12330                        }
12331                        GeneratedField::GroupTopN => {
12332                            if node_body__.is_some() {
12333                                return Err(serde::de::Error::duplicate_field("groupTopN"));
12334                            }
12335                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
12336;
12337                        }
12338                        GeneratedField::Sort => {
12339                            if node_body__.is_some() {
12340                                return Err(serde::de::Error::duplicate_field("sort"));
12341                            }
12342                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
12343;
12344                        }
12345                        GeneratedField::WatermarkFilter => {
12346                            if node_body__.is_some() {
12347                                return Err(serde::de::Error::duplicate_field("watermarkFilter"));
12348                            }
12349                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
12350;
12351                        }
12352                        GeneratedField::Dml => {
12353                            if node_body__.is_some() {
12354                                return Err(serde::de::Error::duplicate_field("dml"));
12355                            }
12356                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
12357;
12358                        }
12359                        GeneratedField::RowIdGen => {
12360                            if node_body__.is_some() {
12361                                return Err(serde::de::Error::duplicate_field("rowIdGen"));
12362                            }
12363                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
12364;
12365                        }
12366                        GeneratedField::Now => {
12367                            if node_body__.is_some() {
12368                                return Err(serde::de::Error::duplicate_field("now"));
12369                            }
12370                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
12371;
12372                        }
12373                        GeneratedField::AppendOnlyGroupTopN => {
12374                            if node_body__.is_some() {
12375                                return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
12376                            }
12377                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
12378;
12379                        }
12380                        GeneratedField::TemporalJoin => {
12381                            if node_body__.is_some() {
12382                                return Err(serde::de::Error::duplicate_field("temporalJoin"));
12383                            }
12384                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
12385;
12386                        }
12387                        GeneratedField::BarrierRecv => {
12388                            if node_body__.is_some() {
12389                                return Err(serde::de::Error::duplicate_field("barrierRecv"));
12390                            }
12391                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
12392;
12393                        }
12394                        GeneratedField::Values => {
12395                            if node_body__.is_some() {
12396                                return Err(serde::de::Error::duplicate_field("values"));
12397                            }
12398                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
12399;
12400                        }
12401                        GeneratedField::AppendOnlyDedup => {
12402                            if node_body__.is_some() {
12403                                return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
12404                            }
12405                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
12406;
12407                        }
12408                        GeneratedField::NoOp => {
12409                            if node_body__.is_some() {
12410                                return Err(serde::de::Error::duplicate_field("noOp"));
12411                            }
12412                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
12413;
12414                        }
12415                        GeneratedField::EowcOverWindow => {
12416                            if node_body__.is_some() {
12417                                return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
12418                            }
12419                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
12420;
12421                        }
12422                        GeneratedField::OverWindow => {
12423                            if node_body__.is_some() {
12424                                return Err(serde::de::Error::duplicate_field("overWindow"));
12425                            }
12426                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
12427;
12428                        }
12429                        GeneratedField::StreamFsFetch => {
12430                            if node_body__.is_some() {
12431                                return Err(serde::de::Error::duplicate_field("streamFsFetch"));
12432                            }
12433                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
12434;
12435                        }
12436                        GeneratedField::StreamCdcScan => {
12437                            if node_body__.is_some() {
12438                                return Err(serde::de::Error::duplicate_field("streamCdcScan"));
12439                            }
12440                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
12441;
12442                        }
12443                        GeneratedField::CdcFilter => {
12444                            if node_body__.is_some() {
12445                                return Err(serde::de::Error::duplicate_field("cdcFilter"));
12446                            }
12447                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
12448;
12449                        }
12450                        GeneratedField::SourceBackfill => {
12451                            if node_body__.is_some() {
12452                                return Err(serde::de::Error::duplicate_field("sourceBackfill"));
12453                            }
12454                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
12455;
12456                        }
12457                        GeneratedField::Changelog => {
12458                            if node_body__.is_some() {
12459                                return Err(serde::de::Error::duplicate_field("changelog"));
12460                            }
12461                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
12462;
12463                        }
12464                        GeneratedField::LocalApproxPercentile => {
12465                            if node_body__.is_some() {
12466                                return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
12467                            }
12468                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
12469;
12470                        }
12471                        GeneratedField::GlobalApproxPercentile => {
12472                            if node_body__.is_some() {
12473                                return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
12474                            }
12475                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
12476;
12477                        }
12478                        GeneratedField::RowMerge => {
12479                            if node_body__.is_some() {
12480                                return Err(serde::de::Error::duplicate_field("rowMerge"));
12481                            }
12482                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
12483;
12484                        }
12485                        GeneratedField::AsOfJoin => {
12486                            if node_body__.is_some() {
12487                                return Err(serde::de::Error::duplicate_field("asOfJoin"));
12488                            }
12489                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
12490;
12491                        }
12492                        GeneratedField::SyncLogStore => {
12493                            if node_body__.is_some() {
12494                                return Err(serde::de::Error::duplicate_field("syncLogStore"));
12495                            }
12496                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
12497;
12498                        }
12499                        GeneratedField::MaterializedExprs => {
12500                            if node_body__.is_some() {
12501                                return Err(serde::de::Error::duplicate_field("materializedExprs"));
12502                            }
12503                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
12504;
12505                        }
12506                    }
12507                }
12508                Ok(StreamNode {
12509                    operator_id: operator_id__.unwrap_or_default(),
12510                    input: input__.unwrap_or_default(),
12511                    stream_key: stream_key__.unwrap_or_default(),
12512                    append_only: append_only__.unwrap_or_default(),
12513                    identity: identity__.unwrap_or_default(),
12514                    fields: fields__.unwrap_or_default(),
12515                    node_body: node_body__,
12516                })
12517            }
12518        }
12519        deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
12520    }
12521}
12522impl serde::Serialize for StreamScanNode {
12523    #[allow(deprecated)]
12524    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12525    where
12526        S: serde::Serializer,
12527    {
12528        use serde::ser::SerializeStruct;
12529        let mut len = 0;
12530        if self.table_id != 0 {
12531            len += 1;
12532        }
12533        if !self.upstream_column_ids.is_empty() {
12534            len += 1;
12535        }
12536        if !self.output_indices.is_empty() {
12537            len += 1;
12538        }
12539        if self.stream_scan_type != 0 {
12540            len += 1;
12541        }
12542        if self.state_table.is_some() {
12543            len += 1;
12544        }
12545        if self.table_desc.is_some() {
12546            len += 1;
12547        }
12548        if self.rate_limit.is_some() {
12549            len += 1;
12550        }
12551        if self.snapshot_read_barrier_interval != 0 {
12552            len += 1;
12553        }
12554        if self.arrangement_table.is_some() {
12555            len += 1;
12556        }
12557        if self.snapshot_backfill_epoch.is_some() {
12558            len += 1;
12559        }
12560        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
12561        if self.table_id != 0 {
12562            struct_ser.serialize_field("tableId", &self.table_id)?;
12563        }
12564        if !self.upstream_column_ids.is_empty() {
12565            struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
12566        }
12567        if !self.output_indices.is_empty() {
12568            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
12569        }
12570        if self.stream_scan_type != 0 {
12571            let v = StreamScanType::try_from(self.stream_scan_type)
12572                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
12573            struct_ser.serialize_field("streamScanType", &v)?;
12574        }
12575        if let Some(v) = self.state_table.as_ref() {
12576            struct_ser.serialize_field("stateTable", v)?;
12577        }
12578        if let Some(v) = self.table_desc.as_ref() {
12579            struct_ser.serialize_field("tableDesc", v)?;
12580        }
12581        if let Some(v) = self.rate_limit.as_ref() {
12582            struct_ser.serialize_field("rateLimit", v)?;
12583        }
12584        if self.snapshot_read_barrier_interval != 0 {
12585            struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
12586        }
12587        if let Some(v) = self.arrangement_table.as_ref() {
12588            struct_ser.serialize_field("arrangementTable", v)?;
12589        }
12590        if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
12591            #[allow(clippy::needless_borrow)]
12592            #[allow(clippy::needless_borrows_for_generic_args)]
12593            struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
12594        }
12595        struct_ser.end()
12596    }
12597}
12598impl<'de> serde::Deserialize<'de> for StreamScanNode {
12599    #[allow(deprecated)]
12600    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12601    where
12602        D: serde::Deserializer<'de>,
12603    {
12604        const FIELDS: &[&str] = &[
12605            "table_id",
12606            "tableId",
12607            "upstream_column_ids",
12608            "upstreamColumnIds",
12609            "output_indices",
12610            "outputIndices",
12611            "stream_scan_type",
12612            "streamScanType",
12613            "state_table",
12614            "stateTable",
12615            "table_desc",
12616            "tableDesc",
12617            "rate_limit",
12618            "rateLimit",
12619            "snapshot_read_barrier_interval",
12620            "snapshotReadBarrierInterval",
12621            "arrangement_table",
12622            "arrangementTable",
12623            "snapshot_backfill_epoch",
12624            "snapshotBackfillEpoch",
12625        ];
12626
12627        #[allow(clippy::enum_variant_names)]
12628        enum GeneratedField {
12629            TableId,
12630            UpstreamColumnIds,
12631            OutputIndices,
12632            StreamScanType,
12633            StateTable,
12634            TableDesc,
12635            RateLimit,
12636            SnapshotReadBarrierInterval,
12637            ArrangementTable,
12638            SnapshotBackfillEpoch,
12639        }
12640        impl<'de> serde::Deserialize<'de> for GeneratedField {
12641            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12642            where
12643                D: serde::Deserializer<'de>,
12644            {
12645                struct GeneratedVisitor;
12646
12647                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12648                    type Value = GeneratedField;
12649
12650                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12651                        write!(formatter, "expected one of: {:?}", &FIELDS)
12652                    }
12653
12654                    #[allow(unused_variables)]
12655                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12656                    where
12657                        E: serde::de::Error,
12658                    {
12659                        match value {
12660                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
12661                            "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
12662                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
12663                            "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
12664                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12665                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
12666                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12667                            "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
12668                            "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
12669                            "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
12670                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12671                        }
12672                    }
12673                }
12674                deserializer.deserialize_identifier(GeneratedVisitor)
12675            }
12676        }
12677        struct GeneratedVisitor;
12678        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12679            type Value = StreamScanNode;
12680
12681            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12682                formatter.write_str("struct stream_plan.StreamScanNode")
12683            }
12684
12685            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
12686                where
12687                    V: serde::de::MapAccess<'de>,
12688            {
12689                let mut table_id__ = None;
12690                let mut upstream_column_ids__ = None;
12691                let mut output_indices__ = None;
12692                let mut stream_scan_type__ = None;
12693                let mut state_table__ = None;
12694                let mut table_desc__ = None;
12695                let mut rate_limit__ = None;
12696                let mut snapshot_read_barrier_interval__ = None;
12697                let mut arrangement_table__ = None;
12698                let mut snapshot_backfill_epoch__ = None;
12699                while let Some(k) = map_.next_key()? {
12700                    match k {
12701                        GeneratedField::TableId => {
12702                            if table_id__.is_some() {
12703                                return Err(serde::de::Error::duplicate_field("tableId"));
12704                            }
12705                            table_id__ = 
12706                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12707                            ;
12708                        }
12709                        GeneratedField::UpstreamColumnIds => {
12710                            if upstream_column_ids__.is_some() {
12711                                return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
12712                            }
12713                            upstream_column_ids__ = 
12714                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12715                                    .into_iter().map(|x| x.0).collect())
12716                            ;
12717                        }
12718                        GeneratedField::OutputIndices => {
12719                            if output_indices__.is_some() {
12720                                return Err(serde::de::Error::duplicate_field("outputIndices"));
12721                            }
12722                            output_indices__ = 
12723                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12724                                    .into_iter().map(|x| x.0).collect())
12725                            ;
12726                        }
12727                        GeneratedField::StreamScanType => {
12728                            if stream_scan_type__.is_some() {
12729                                return Err(serde::de::Error::duplicate_field("streamScanType"));
12730                            }
12731                            stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
12732                        }
12733                        GeneratedField::StateTable => {
12734                            if state_table__.is_some() {
12735                                return Err(serde::de::Error::duplicate_field("stateTable"));
12736                            }
12737                            state_table__ = map_.next_value()?;
12738                        }
12739                        GeneratedField::TableDesc => {
12740                            if table_desc__.is_some() {
12741                                return Err(serde::de::Error::duplicate_field("tableDesc"));
12742                            }
12743                            table_desc__ = map_.next_value()?;
12744                        }
12745                        GeneratedField::RateLimit => {
12746                            if rate_limit__.is_some() {
12747                                return Err(serde::de::Error::duplicate_field("rateLimit"));
12748                            }
12749                            rate_limit__ = 
12750                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12751                            ;
12752                        }
12753                        GeneratedField::SnapshotReadBarrierInterval => {
12754                            if snapshot_read_barrier_interval__.is_some() {
12755                                return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
12756                            }
12757                            snapshot_read_barrier_interval__ = 
12758                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12759                            ;
12760                        }
12761                        GeneratedField::ArrangementTable => {
12762                            if arrangement_table__.is_some() {
12763                                return Err(serde::de::Error::duplicate_field("arrangementTable"));
12764                            }
12765                            arrangement_table__ = map_.next_value()?;
12766                        }
12767                        GeneratedField::SnapshotBackfillEpoch => {
12768                            if snapshot_backfill_epoch__.is_some() {
12769                                return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
12770                            }
12771                            snapshot_backfill_epoch__ = 
12772                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12773                            ;
12774                        }
12775                    }
12776                }
12777                Ok(StreamScanNode {
12778                    table_id: table_id__.unwrap_or_default(),
12779                    upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
12780                    output_indices: output_indices__.unwrap_or_default(),
12781                    stream_scan_type: stream_scan_type__.unwrap_or_default(),
12782                    state_table: state_table__,
12783                    table_desc: table_desc__,
12784                    rate_limit: rate_limit__,
12785                    snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
12786                    arrangement_table: arrangement_table__,
12787                    snapshot_backfill_epoch: snapshot_backfill_epoch__,
12788                })
12789            }
12790        }
12791        deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
12792    }
12793}
12794impl serde::Serialize for StreamScanType {
12795    #[allow(deprecated)]
12796    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12797    where
12798        S: serde::Serializer,
12799    {
12800        let variant = match self {
12801            Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
12802            Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
12803            Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
12804            Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
12805            Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
12806            Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
12807            Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
12808            Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
12809        };
12810        serializer.serialize_str(variant)
12811    }
12812}
12813impl<'de> serde::Deserialize<'de> for StreamScanType {
12814    #[allow(deprecated)]
12815    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12816    where
12817        D: serde::Deserializer<'de>,
12818    {
12819        const FIELDS: &[&str] = &[
12820            "STREAM_SCAN_TYPE_UNSPECIFIED",
12821            "STREAM_SCAN_TYPE_CHAIN",
12822            "STREAM_SCAN_TYPE_REARRANGE",
12823            "STREAM_SCAN_TYPE_BACKFILL",
12824            "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
12825            "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
12826            "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
12827            "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
12828        ];
12829
12830        struct GeneratedVisitor;
12831
12832        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12833            type Value = StreamScanType;
12834
12835            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12836                write!(formatter, "expected one of: {:?}", &FIELDS)
12837            }
12838
12839            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
12840            where
12841                E: serde::de::Error,
12842            {
12843                i32::try_from(v)
12844                    .ok()
12845                    .and_then(|x| x.try_into().ok())
12846                    .ok_or_else(|| {
12847                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12848                    })
12849            }
12850
12851            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12852            where
12853                E: serde::de::Error,
12854            {
12855                i32::try_from(v)
12856                    .ok()
12857                    .and_then(|x| x.try_into().ok())
12858                    .ok_or_else(|| {
12859                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12860                    })
12861            }
12862
12863            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12864            where
12865                E: serde::de::Error,
12866            {
12867                match value {
12868                    "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
12869                    "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
12870                    "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
12871                    "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
12872                    "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
12873                    "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
12874                    "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
12875                    "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
12876                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12877                }
12878            }
12879        }
12880        deserializer.deserialize_any(GeneratedVisitor)
12881    }
12882}
12883impl serde::Serialize for StreamSource {
12884    #[allow(deprecated)]
12885    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12886    where
12887        S: serde::Serializer,
12888    {
12889        use serde::ser::SerializeStruct;
12890        let mut len = 0;
12891        if self.source_id != 0 {
12892            len += 1;
12893        }
12894        if self.state_table.is_some() {
12895            len += 1;
12896        }
12897        if self.row_id_index.is_some() {
12898            len += 1;
12899        }
12900        if !self.columns.is_empty() {
12901            len += 1;
12902        }
12903        if !self.with_properties.is_empty() {
12904            len += 1;
12905        }
12906        if self.info.is_some() {
12907            len += 1;
12908        }
12909        if !self.source_name.is_empty() {
12910            len += 1;
12911        }
12912        if self.rate_limit.is_some() {
12913            len += 1;
12914        }
12915        if !self.secret_refs.is_empty() {
12916            len += 1;
12917        }
12918        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
12919        if self.source_id != 0 {
12920            struct_ser.serialize_field("sourceId", &self.source_id)?;
12921        }
12922        if let Some(v) = self.state_table.as_ref() {
12923            struct_ser.serialize_field("stateTable", v)?;
12924        }
12925        if let Some(v) = self.row_id_index.as_ref() {
12926            struct_ser.serialize_field("rowIdIndex", v)?;
12927        }
12928        if !self.columns.is_empty() {
12929            struct_ser.serialize_field("columns", &self.columns)?;
12930        }
12931        if !self.with_properties.is_empty() {
12932            struct_ser.serialize_field("withProperties", &self.with_properties)?;
12933        }
12934        if let Some(v) = self.info.as_ref() {
12935            struct_ser.serialize_field("info", v)?;
12936        }
12937        if !self.source_name.is_empty() {
12938            struct_ser.serialize_field("sourceName", &self.source_name)?;
12939        }
12940        if let Some(v) = self.rate_limit.as_ref() {
12941            struct_ser.serialize_field("rateLimit", v)?;
12942        }
12943        if !self.secret_refs.is_empty() {
12944            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
12945        }
12946        struct_ser.end()
12947    }
12948}
12949impl<'de> serde::Deserialize<'de> for StreamSource {
12950    #[allow(deprecated)]
12951    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12952    where
12953        D: serde::Deserializer<'de>,
12954    {
12955        const FIELDS: &[&str] = &[
12956            "source_id",
12957            "sourceId",
12958            "state_table",
12959            "stateTable",
12960            "row_id_index",
12961            "rowIdIndex",
12962            "columns",
12963            "with_properties",
12964            "withProperties",
12965            "info",
12966            "source_name",
12967            "sourceName",
12968            "rate_limit",
12969            "rateLimit",
12970            "secret_refs",
12971            "secretRefs",
12972        ];
12973
12974        #[allow(clippy::enum_variant_names)]
12975        enum GeneratedField {
12976            SourceId,
12977            StateTable,
12978            RowIdIndex,
12979            Columns,
12980            WithProperties,
12981            Info,
12982            SourceName,
12983            RateLimit,
12984            SecretRefs,
12985        }
12986        impl<'de> serde::Deserialize<'de> for GeneratedField {
12987            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12988            where
12989                D: serde::Deserializer<'de>,
12990            {
12991                struct GeneratedVisitor;
12992
12993                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12994                    type Value = GeneratedField;
12995
12996                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12997                        write!(formatter, "expected one of: {:?}", &FIELDS)
12998                    }
12999
13000                    #[allow(unused_variables)]
13001                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13002                    where
13003                        E: serde::de::Error,
13004                    {
13005                        match value {
13006                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
13007                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13008                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
13009                            "columns" => Ok(GeneratedField::Columns),
13010                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
13011                            "info" => Ok(GeneratedField::Info),
13012                            "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
13013                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13014                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13015                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13016                        }
13017                    }
13018                }
13019                deserializer.deserialize_identifier(GeneratedVisitor)
13020            }
13021        }
13022        struct GeneratedVisitor;
13023        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13024            type Value = StreamSource;
13025
13026            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13027                formatter.write_str("struct stream_plan.StreamSource")
13028            }
13029
13030            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
13031                where
13032                    V: serde::de::MapAccess<'de>,
13033            {
13034                let mut source_id__ = None;
13035                let mut state_table__ = None;
13036                let mut row_id_index__ = None;
13037                let mut columns__ = None;
13038                let mut with_properties__ = None;
13039                let mut info__ = None;
13040                let mut source_name__ = None;
13041                let mut rate_limit__ = None;
13042                let mut secret_refs__ = None;
13043                while let Some(k) = map_.next_key()? {
13044                    match k {
13045                        GeneratedField::SourceId => {
13046                            if source_id__.is_some() {
13047                                return Err(serde::de::Error::duplicate_field("sourceId"));
13048                            }
13049                            source_id__ = 
13050                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13051                            ;
13052                        }
13053                        GeneratedField::StateTable => {
13054                            if state_table__.is_some() {
13055                                return Err(serde::de::Error::duplicate_field("stateTable"));
13056                            }
13057                            state_table__ = map_.next_value()?;
13058                        }
13059                        GeneratedField::RowIdIndex => {
13060                            if row_id_index__.is_some() {
13061                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
13062                            }
13063                            row_id_index__ = 
13064                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13065                            ;
13066                        }
13067                        GeneratedField::Columns => {
13068                            if columns__.is_some() {
13069                                return Err(serde::de::Error::duplicate_field("columns"));
13070                            }
13071                            columns__ = Some(map_.next_value()?);
13072                        }
13073                        GeneratedField::WithProperties => {
13074                            if with_properties__.is_some() {
13075                                return Err(serde::de::Error::duplicate_field("withProperties"));
13076                            }
13077                            with_properties__ = Some(
13078                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
13079                            );
13080                        }
13081                        GeneratedField::Info => {
13082                            if info__.is_some() {
13083                                return Err(serde::de::Error::duplicate_field("info"));
13084                            }
13085                            info__ = map_.next_value()?;
13086                        }
13087                        GeneratedField::SourceName => {
13088                            if source_name__.is_some() {
13089                                return Err(serde::de::Error::duplicate_field("sourceName"));
13090                            }
13091                            source_name__ = Some(map_.next_value()?);
13092                        }
13093                        GeneratedField::RateLimit => {
13094                            if rate_limit__.is_some() {
13095                                return Err(serde::de::Error::duplicate_field("rateLimit"));
13096                            }
13097                            rate_limit__ = 
13098                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13099                            ;
13100                        }
13101                        GeneratedField::SecretRefs => {
13102                            if secret_refs__.is_some() {
13103                                return Err(serde::de::Error::duplicate_field("secretRefs"));
13104                            }
13105                            secret_refs__ = Some(
13106                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
13107                            );
13108                        }
13109                    }
13110                }
13111                Ok(StreamSource {
13112                    source_id: source_id__.unwrap_or_default(),
13113                    state_table: state_table__,
13114                    row_id_index: row_id_index__,
13115                    columns: columns__.unwrap_or_default(),
13116                    with_properties: with_properties__.unwrap_or_default(),
13117                    info: info__,
13118                    source_name: source_name__.unwrap_or_default(),
13119                    rate_limit: rate_limit__,
13120                    secret_refs: secret_refs__.unwrap_or_default(),
13121                })
13122            }
13123        }
13124        deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
13125    }
13126}
13127impl serde::Serialize for SubscriptionUpstreamInfo {
13128    #[allow(deprecated)]
13129    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13130    where
13131        S: serde::Serializer,
13132    {
13133        use serde::ser::SerializeStruct;
13134        let mut len = 0;
13135        if self.subscriber_id != 0 {
13136            len += 1;
13137        }
13138        if self.upstream_mv_table_id != 0 {
13139            len += 1;
13140        }
13141        let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
13142        if self.subscriber_id != 0 {
13143            struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
13144        }
13145        if self.upstream_mv_table_id != 0 {
13146            struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
13147        }
13148        struct_ser.end()
13149    }
13150}
13151impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
13152    #[allow(deprecated)]
13153    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13154    where
13155        D: serde::Deserializer<'de>,
13156    {
13157        const FIELDS: &[&str] = &[
13158            "subscriber_id",
13159            "subscriberId",
13160            "upstream_mv_table_id",
13161            "upstreamMvTableId",
13162        ];
13163
13164        #[allow(clippy::enum_variant_names)]
13165        enum GeneratedField {
13166            SubscriberId,
13167            UpstreamMvTableId,
13168        }
13169        impl<'de> serde::Deserialize<'de> for GeneratedField {
13170            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13171            where
13172                D: serde::Deserializer<'de>,
13173            {
13174                struct GeneratedVisitor;
13175
13176                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13177                    type Value = GeneratedField;
13178
13179                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13180                        write!(formatter, "expected one of: {:?}", &FIELDS)
13181                    }
13182
13183                    #[allow(unused_variables)]
13184                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13185                    where
13186                        E: serde::de::Error,
13187                    {
13188                        match value {
13189                            "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
13190                            "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
13191                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13192                        }
13193                    }
13194                }
13195                deserializer.deserialize_identifier(GeneratedVisitor)
13196            }
13197        }
13198        struct GeneratedVisitor;
13199        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13200            type Value = SubscriptionUpstreamInfo;
13201
13202            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13203                formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
13204            }
13205
13206            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
13207                where
13208                    V: serde::de::MapAccess<'de>,
13209            {
13210                let mut subscriber_id__ = None;
13211                let mut upstream_mv_table_id__ = None;
13212                while let Some(k) = map_.next_key()? {
13213                    match k {
13214                        GeneratedField::SubscriberId => {
13215                            if subscriber_id__.is_some() {
13216                                return Err(serde::de::Error::duplicate_field("subscriberId"));
13217                            }
13218                            subscriber_id__ = 
13219                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13220                            ;
13221                        }
13222                        GeneratedField::UpstreamMvTableId => {
13223                            if upstream_mv_table_id__.is_some() {
13224                                return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
13225                            }
13226                            upstream_mv_table_id__ = 
13227                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13228                            ;
13229                        }
13230                    }
13231                }
13232                Ok(SubscriptionUpstreamInfo {
13233                    subscriber_id: subscriber_id__.unwrap_or_default(),
13234                    upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
13235                })
13236            }
13237        }
13238        deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
13239    }
13240}
13241impl serde::Serialize for SyncLogStoreNode {
13242    #[allow(deprecated)]
13243    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13244    where
13245        S: serde::Serializer,
13246    {
13247        use serde::ser::SerializeStruct;
13248        let mut len = 0;
13249        if self.log_store_table.is_some() {
13250            len += 1;
13251        }
13252        if self.pause_duration_ms != 0 {
13253            len += 1;
13254        }
13255        if self.buffer_size != 0 {
13256            len += 1;
13257        }
13258        if self.aligned {
13259            len += 1;
13260        }
13261        let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
13262        if let Some(v) = self.log_store_table.as_ref() {
13263            struct_ser.serialize_field("logStoreTable", v)?;
13264        }
13265        if self.pause_duration_ms != 0 {
13266            struct_ser.serialize_field("pauseDurationMs", &self.pause_duration_ms)?;
13267        }
13268        if self.buffer_size != 0 {
13269            struct_ser.serialize_field("bufferSize", &self.buffer_size)?;
13270        }
13271        if self.aligned {
13272            struct_ser.serialize_field("aligned", &self.aligned)?;
13273        }
13274        struct_ser.end()
13275    }
13276}
13277impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
13278    #[allow(deprecated)]
13279    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13280    where
13281        D: serde::Deserializer<'de>,
13282    {
13283        const FIELDS: &[&str] = &[
13284            "log_store_table",
13285            "logStoreTable",
13286            "pause_duration_ms",
13287            "pauseDurationMs",
13288            "buffer_size",
13289            "bufferSize",
13290            "aligned",
13291        ];
13292
13293        #[allow(clippy::enum_variant_names)]
13294        enum GeneratedField {
13295            LogStoreTable,
13296            PauseDurationMs,
13297            BufferSize,
13298            Aligned,
13299        }
13300        impl<'de> serde::Deserialize<'de> for GeneratedField {
13301            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13302            where
13303                D: serde::Deserializer<'de>,
13304            {
13305                struct GeneratedVisitor;
13306
13307                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13308                    type Value = GeneratedField;
13309
13310                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13311                        write!(formatter, "expected one of: {:?}", &FIELDS)
13312                    }
13313
13314                    #[allow(unused_variables)]
13315                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13316                    where
13317                        E: serde::de::Error,
13318                    {
13319                        match value {
13320                            "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
13321                            "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
13322                            "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
13323                            "aligned" => Ok(GeneratedField::Aligned),
13324                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13325                        }
13326                    }
13327                }
13328                deserializer.deserialize_identifier(GeneratedVisitor)
13329            }
13330        }
13331        struct GeneratedVisitor;
13332        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13333            type Value = SyncLogStoreNode;
13334
13335            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13336                formatter.write_str("struct stream_plan.SyncLogStoreNode")
13337            }
13338
13339            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
13340                where
13341                    V: serde::de::MapAccess<'de>,
13342            {
13343                let mut log_store_table__ = None;
13344                let mut pause_duration_ms__ = None;
13345                let mut buffer_size__ = None;
13346                let mut aligned__ = None;
13347                while let Some(k) = map_.next_key()? {
13348                    match k {
13349                        GeneratedField::LogStoreTable => {
13350                            if log_store_table__.is_some() {
13351                                return Err(serde::de::Error::duplicate_field("logStoreTable"));
13352                            }
13353                            log_store_table__ = map_.next_value()?;
13354                        }
13355                        GeneratedField::PauseDurationMs => {
13356                            if pause_duration_ms__.is_some() {
13357                                return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
13358                            }
13359                            pause_duration_ms__ = 
13360                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13361                            ;
13362                        }
13363                        GeneratedField::BufferSize => {
13364                            if buffer_size__.is_some() {
13365                                return Err(serde::de::Error::duplicate_field("bufferSize"));
13366                            }
13367                            buffer_size__ = 
13368                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13369                            ;
13370                        }
13371                        GeneratedField::Aligned => {
13372                            if aligned__.is_some() {
13373                                return Err(serde::de::Error::duplicate_field("aligned"));
13374                            }
13375                            aligned__ = Some(map_.next_value()?);
13376                        }
13377                    }
13378                }
13379                Ok(SyncLogStoreNode {
13380                    log_store_table: log_store_table__,
13381                    pause_duration_ms: pause_duration_ms__.unwrap_or_default(),
13382                    buffer_size: buffer_size__.unwrap_or_default(),
13383                    aligned: aligned__.unwrap_or_default(),
13384                })
13385            }
13386        }
13387        deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
13388    }
13389}
13390impl serde::Serialize for TemporalJoinNode {
13391    #[allow(deprecated)]
13392    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13393    where
13394        S: serde::Serializer,
13395    {
13396        use serde::ser::SerializeStruct;
13397        let mut len = 0;
13398        if self.join_type != 0 {
13399            len += 1;
13400        }
13401        if !self.left_key.is_empty() {
13402            len += 1;
13403        }
13404        if !self.right_key.is_empty() {
13405            len += 1;
13406        }
13407        if !self.null_safe.is_empty() {
13408            len += 1;
13409        }
13410        if self.condition.is_some() {
13411            len += 1;
13412        }
13413        if !self.output_indices.is_empty() {
13414            len += 1;
13415        }
13416        if self.table_desc.is_some() {
13417            len += 1;
13418        }
13419        if !self.table_output_indices.is_empty() {
13420            len += 1;
13421        }
13422        if self.memo_table.is_some() {
13423            len += 1;
13424        }
13425        if self.is_nested_loop {
13426            len += 1;
13427        }
13428        let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
13429        if self.join_type != 0 {
13430            let v = super::plan_common::JoinType::try_from(self.join_type)
13431                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
13432            struct_ser.serialize_field("joinType", &v)?;
13433        }
13434        if !self.left_key.is_empty() {
13435            struct_ser.serialize_field("leftKey", &self.left_key)?;
13436        }
13437        if !self.right_key.is_empty() {
13438            struct_ser.serialize_field("rightKey", &self.right_key)?;
13439        }
13440        if !self.null_safe.is_empty() {
13441            struct_ser.serialize_field("nullSafe", &self.null_safe)?;
13442        }
13443        if let Some(v) = self.condition.as_ref() {
13444            struct_ser.serialize_field("condition", v)?;
13445        }
13446        if !self.output_indices.is_empty() {
13447            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
13448        }
13449        if let Some(v) = self.table_desc.as_ref() {
13450            struct_ser.serialize_field("tableDesc", v)?;
13451        }
13452        if !self.table_output_indices.is_empty() {
13453            struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
13454        }
13455        if let Some(v) = self.memo_table.as_ref() {
13456            struct_ser.serialize_field("memoTable", v)?;
13457        }
13458        if self.is_nested_loop {
13459            struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
13460        }
13461        struct_ser.end()
13462    }
13463}
13464impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
13465    #[allow(deprecated)]
13466    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13467    where
13468        D: serde::Deserializer<'de>,
13469    {
13470        const FIELDS: &[&str] = &[
13471            "join_type",
13472            "joinType",
13473            "left_key",
13474            "leftKey",
13475            "right_key",
13476            "rightKey",
13477            "null_safe",
13478            "nullSafe",
13479            "condition",
13480            "output_indices",
13481            "outputIndices",
13482            "table_desc",
13483            "tableDesc",
13484            "table_output_indices",
13485            "tableOutputIndices",
13486            "memo_table",
13487            "memoTable",
13488            "is_nested_loop",
13489            "isNestedLoop",
13490        ];
13491
13492        #[allow(clippy::enum_variant_names)]
13493        enum GeneratedField {
13494            JoinType,
13495            LeftKey,
13496            RightKey,
13497            NullSafe,
13498            Condition,
13499            OutputIndices,
13500            TableDesc,
13501            TableOutputIndices,
13502            MemoTable,
13503            IsNestedLoop,
13504        }
13505        impl<'de> serde::Deserialize<'de> for GeneratedField {
13506            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13507            where
13508                D: serde::Deserializer<'de>,
13509            {
13510                struct GeneratedVisitor;
13511
13512                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13513                    type Value = GeneratedField;
13514
13515                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13516                        write!(formatter, "expected one of: {:?}", &FIELDS)
13517                    }
13518
13519                    #[allow(unused_variables)]
13520                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13521                    where
13522                        E: serde::de::Error,
13523                    {
13524                        match value {
13525                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
13526                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
13527                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
13528                            "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
13529                            "condition" => Ok(GeneratedField::Condition),
13530                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
13531                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
13532                            "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
13533                            "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
13534                            "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
13535                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13536                        }
13537                    }
13538                }
13539                deserializer.deserialize_identifier(GeneratedVisitor)
13540            }
13541        }
13542        struct GeneratedVisitor;
13543        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13544            type Value = TemporalJoinNode;
13545
13546            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13547                formatter.write_str("struct stream_plan.TemporalJoinNode")
13548            }
13549
13550            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
13551                where
13552                    V: serde::de::MapAccess<'de>,
13553            {
13554                let mut join_type__ = None;
13555                let mut left_key__ = None;
13556                let mut right_key__ = None;
13557                let mut null_safe__ = None;
13558                let mut condition__ = None;
13559                let mut output_indices__ = None;
13560                let mut table_desc__ = None;
13561                let mut table_output_indices__ = None;
13562                let mut memo_table__ = None;
13563                let mut is_nested_loop__ = None;
13564                while let Some(k) = map_.next_key()? {
13565                    match k {
13566                        GeneratedField::JoinType => {
13567                            if join_type__.is_some() {
13568                                return Err(serde::de::Error::duplicate_field("joinType"));
13569                            }
13570                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
13571                        }
13572                        GeneratedField::LeftKey => {
13573                            if left_key__.is_some() {
13574                                return Err(serde::de::Error::duplicate_field("leftKey"));
13575                            }
13576                            left_key__ = 
13577                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13578                                    .into_iter().map(|x| x.0).collect())
13579                            ;
13580                        }
13581                        GeneratedField::RightKey => {
13582                            if right_key__.is_some() {
13583                                return Err(serde::de::Error::duplicate_field("rightKey"));
13584                            }
13585                            right_key__ = 
13586                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13587                                    .into_iter().map(|x| x.0).collect())
13588                            ;
13589                        }
13590                        GeneratedField::NullSafe => {
13591                            if null_safe__.is_some() {
13592                                return Err(serde::de::Error::duplicate_field("nullSafe"));
13593                            }
13594                            null_safe__ = Some(map_.next_value()?);
13595                        }
13596                        GeneratedField::Condition => {
13597                            if condition__.is_some() {
13598                                return Err(serde::de::Error::duplicate_field("condition"));
13599                            }
13600                            condition__ = map_.next_value()?;
13601                        }
13602                        GeneratedField::OutputIndices => {
13603                            if output_indices__.is_some() {
13604                                return Err(serde::de::Error::duplicate_field("outputIndices"));
13605                            }
13606                            output_indices__ = 
13607                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13608                                    .into_iter().map(|x| x.0).collect())
13609                            ;
13610                        }
13611                        GeneratedField::TableDesc => {
13612                            if table_desc__.is_some() {
13613                                return Err(serde::de::Error::duplicate_field("tableDesc"));
13614                            }
13615                            table_desc__ = map_.next_value()?;
13616                        }
13617                        GeneratedField::TableOutputIndices => {
13618                            if table_output_indices__.is_some() {
13619                                return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
13620                            }
13621                            table_output_indices__ = 
13622                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13623                                    .into_iter().map(|x| x.0).collect())
13624                            ;
13625                        }
13626                        GeneratedField::MemoTable => {
13627                            if memo_table__.is_some() {
13628                                return Err(serde::de::Error::duplicate_field("memoTable"));
13629                            }
13630                            memo_table__ = map_.next_value()?;
13631                        }
13632                        GeneratedField::IsNestedLoop => {
13633                            if is_nested_loop__.is_some() {
13634                                return Err(serde::de::Error::duplicate_field("isNestedLoop"));
13635                            }
13636                            is_nested_loop__ = Some(map_.next_value()?);
13637                        }
13638                    }
13639                }
13640                Ok(TemporalJoinNode {
13641                    join_type: join_type__.unwrap_or_default(),
13642                    left_key: left_key__.unwrap_or_default(),
13643                    right_key: right_key__.unwrap_or_default(),
13644                    null_safe: null_safe__.unwrap_or_default(),
13645                    condition: condition__,
13646                    output_indices: output_indices__.unwrap_or_default(),
13647                    table_desc: table_desc__,
13648                    table_output_indices: table_output_indices__.unwrap_or_default(),
13649                    memo_table: memo_table__,
13650                    is_nested_loop: is_nested_loop__.unwrap_or_default(),
13651                })
13652            }
13653        }
13654        deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
13655    }
13656}
13657impl serde::Serialize for ThrottleMutation {
13658    #[allow(deprecated)]
13659    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13660    where
13661        S: serde::Serializer,
13662    {
13663        use serde::ser::SerializeStruct;
13664        let mut len = 0;
13665        if !self.actor_throttle.is_empty() {
13666            len += 1;
13667        }
13668        let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
13669        if !self.actor_throttle.is_empty() {
13670            struct_ser.serialize_field("actorThrottle", &self.actor_throttle)?;
13671        }
13672        struct_ser.end()
13673    }
13674}
13675impl<'de> serde::Deserialize<'de> for ThrottleMutation {
13676    #[allow(deprecated)]
13677    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13678    where
13679        D: serde::Deserializer<'de>,
13680    {
13681        const FIELDS: &[&str] = &[
13682            "actor_throttle",
13683            "actorThrottle",
13684        ];
13685
13686        #[allow(clippy::enum_variant_names)]
13687        enum GeneratedField {
13688            ActorThrottle,
13689        }
13690        impl<'de> serde::Deserialize<'de> for GeneratedField {
13691            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13692            where
13693                D: serde::Deserializer<'de>,
13694            {
13695                struct GeneratedVisitor;
13696
13697                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13698                    type Value = GeneratedField;
13699
13700                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13701                        write!(formatter, "expected one of: {:?}", &FIELDS)
13702                    }
13703
13704                    #[allow(unused_variables)]
13705                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13706                    where
13707                        E: serde::de::Error,
13708                    {
13709                        match value {
13710                            "actorThrottle" | "actor_throttle" => Ok(GeneratedField::ActorThrottle),
13711                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13712                        }
13713                    }
13714                }
13715                deserializer.deserialize_identifier(GeneratedVisitor)
13716            }
13717        }
13718        struct GeneratedVisitor;
13719        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13720            type Value = ThrottleMutation;
13721
13722            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13723                formatter.write_str("struct stream_plan.ThrottleMutation")
13724            }
13725
13726            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
13727                where
13728                    V: serde::de::MapAccess<'de>,
13729            {
13730                let mut actor_throttle__ = None;
13731                while let Some(k) = map_.next_key()? {
13732                    match k {
13733                        GeneratedField::ActorThrottle => {
13734                            if actor_throttle__.is_some() {
13735                                return Err(serde::de::Error::duplicate_field("actorThrottle"));
13736                            }
13737                            actor_throttle__ = Some(
13738                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13739                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
13740                            );
13741                        }
13742                    }
13743                }
13744                Ok(ThrottleMutation {
13745                    actor_throttle: actor_throttle__.unwrap_or_default(),
13746                })
13747            }
13748        }
13749        deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
13750    }
13751}
13752impl serde::Serialize for throttle_mutation::RateLimit {
13753    #[allow(deprecated)]
13754    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13755    where
13756        S: serde::Serializer,
13757    {
13758        use serde::ser::SerializeStruct;
13759        let mut len = 0;
13760        if self.rate_limit.is_some() {
13761            len += 1;
13762        }
13763        let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.RateLimit", len)?;
13764        if let Some(v) = self.rate_limit.as_ref() {
13765            struct_ser.serialize_field("rateLimit", v)?;
13766        }
13767        struct_ser.end()
13768    }
13769}
13770impl<'de> serde::Deserialize<'de> for throttle_mutation::RateLimit {
13771    #[allow(deprecated)]
13772    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13773    where
13774        D: serde::Deserializer<'de>,
13775    {
13776        const FIELDS: &[&str] = &[
13777            "rate_limit",
13778            "rateLimit",
13779        ];
13780
13781        #[allow(clippy::enum_variant_names)]
13782        enum GeneratedField {
13783            RateLimit,
13784        }
13785        impl<'de> serde::Deserialize<'de> for GeneratedField {
13786            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13787            where
13788                D: serde::Deserializer<'de>,
13789            {
13790                struct GeneratedVisitor;
13791
13792                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13793                    type Value = GeneratedField;
13794
13795                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13796                        write!(formatter, "expected one of: {:?}", &FIELDS)
13797                    }
13798
13799                    #[allow(unused_variables)]
13800                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13801                    where
13802                        E: serde::de::Error,
13803                    {
13804                        match value {
13805                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13806                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13807                        }
13808                    }
13809                }
13810                deserializer.deserialize_identifier(GeneratedVisitor)
13811            }
13812        }
13813        struct GeneratedVisitor;
13814        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13815            type Value = throttle_mutation::RateLimit;
13816
13817            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13818                formatter.write_str("struct stream_plan.ThrottleMutation.RateLimit")
13819            }
13820
13821            fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::RateLimit, V::Error>
13822                where
13823                    V: serde::de::MapAccess<'de>,
13824            {
13825                let mut rate_limit__ = None;
13826                while let Some(k) = map_.next_key()? {
13827                    match k {
13828                        GeneratedField::RateLimit => {
13829                            if rate_limit__.is_some() {
13830                                return Err(serde::de::Error::duplicate_field("rateLimit"));
13831                            }
13832                            rate_limit__ = 
13833                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13834                            ;
13835                        }
13836                    }
13837                }
13838                Ok(throttle_mutation::RateLimit {
13839                    rate_limit: rate_limit__,
13840                })
13841            }
13842        }
13843        deserializer.deserialize_struct("stream_plan.ThrottleMutation.RateLimit", FIELDS, GeneratedVisitor)
13844    }
13845}
13846impl serde::Serialize for TopNNode {
13847    #[allow(deprecated)]
13848    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13849    where
13850        S: serde::Serializer,
13851    {
13852        use serde::ser::SerializeStruct;
13853        let mut len = 0;
13854        if self.limit != 0 {
13855            len += 1;
13856        }
13857        if self.offset != 0 {
13858            len += 1;
13859        }
13860        if self.table.is_some() {
13861            len += 1;
13862        }
13863        if !self.order_by.is_empty() {
13864            len += 1;
13865        }
13866        if self.with_ties {
13867            len += 1;
13868        }
13869        let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
13870        if self.limit != 0 {
13871            #[allow(clippy::needless_borrow)]
13872            #[allow(clippy::needless_borrows_for_generic_args)]
13873            struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
13874        }
13875        if self.offset != 0 {
13876            #[allow(clippy::needless_borrow)]
13877            #[allow(clippy::needless_borrows_for_generic_args)]
13878            struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
13879        }
13880        if let Some(v) = self.table.as_ref() {
13881            struct_ser.serialize_field("table", v)?;
13882        }
13883        if !self.order_by.is_empty() {
13884            struct_ser.serialize_field("orderBy", &self.order_by)?;
13885        }
13886        if self.with_ties {
13887            struct_ser.serialize_field("withTies", &self.with_ties)?;
13888        }
13889        struct_ser.end()
13890    }
13891}
13892impl<'de> serde::Deserialize<'de> for TopNNode {
13893    #[allow(deprecated)]
13894    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13895    where
13896        D: serde::Deserializer<'de>,
13897    {
13898        const FIELDS: &[&str] = &[
13899            "limit",
13900            "offset",
13901            "table",
13902            "order_by",
13903            "orderBy",
13904            "with_ties",
13905            "withTies",
13906        ];
13907
13908        #[allow(clippy::enum_variant_names)]
13909        enum GeneratedField {
13910            Limit,
13911            Offset,
13912            Table,
13913            OrderBy,
13914            WithTies,
13915        }
13916        impl<'de> serde::Deserialize<'de> for GeneratedField {
13917            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13918            where
13919                D: serde::Deserializer<'de>,
13920            {
13921                struct GeneratedVisitor;
13922
13923                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13924                    type Value = GeneratedField;
13925
13926                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13927                        write!(formatter, "expected one of: {:?}", &FIELDS)
13928                    }
13929
13930                    #[allow(unused_variables)]
13931                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13932                    where
13933                        E: serde::de::Error,
13934                    {
13935                        match value {
13936                            "limit" => Ok(GeneratedField::Limit),
13937                            "offset" => Ok(GeneratedField::Offset),
13938                            "table" => Ok(GeneratedField::Table),
13939                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
13940                            "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
13941                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13942                        }
13943                    }
13944                }
13945                deserializer.deserialize_identifier(GeneratedVisitor)
13946            }
13947        }
13948        struct GeneratedVisitor;
13949        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13950            type Value = TopNNode;
13951
13952            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13953                formatter.write_str("struct stream_plan.TopNNode")
13954            }
13955
13956            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
13957                where
13958                    V: serde::de::MapAccess<'de>,
13959            {
13960                let mut limit__ = None;
13961                let mut offset__ = None;
13962                let mut table__ = None;
13963                let mut order_by__ = None;
13964                let mut with_ties__ = None;
13965                while let Some(k) = map_.next_key()? {
13966                    match k {
13967                        GeneratedField::Limit => {
13968                            if limit__.is_some() {
13969                                return Err(serde::de::Error::duplicate_field("limit"));
13970                            }
13971                            limit__ = 
13972                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13973                            ;
13974                        }
13975                        GeneratedField::Offset => {
13976                            if offset__.is_some() {
13977                                return Err(serde::de::Error::duplicate_field("offset"));
13978                            }
13979                            offset__ = 
13980                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13981                            ;
13982                        }
13983                        GeneratedField::Table => {
13984                            if table__.is_some() {
13985                                return Err(serde::de::Error::duplicate_field("table"));
13986                            }
13987                            table__ = map_.next_value()?;
13988                        }
13989                        GeneratedField::OrderBy => {
13990                            if order_by__.is_some() {
13991                                return Err(serde::de::Error::duplicate_field("orderBy"));
13992                            }
13993                            order_by__ = Some(map_.next_value()?);
13994                        }
13995                        GeneratedField::WithTies => {
13996                            if with_ties__.is_some() {
13997                                return Err(serde::de::Error::duplicate_field("withTies"));
13998                            }
13999                            with_ties__ = Some(map_.next_value()?);
14000                        }
14001                    }
14002                }
14003                Ok(TopNNode {
14004                    limit: limit__.unwrap_or_default(),
14005                    offset: offset__.unwrap_or_default(),
14006                    table: table__,
14007                    order_by: order_by__.unwrap_or_default(),
14008                    with_ties: with_ties__.unwrap_or_default(),
14009                })
14010            }
14011        }
14012        deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
14013    }
14014}
14015impl serde::Serialize for UnionNode {
14016    #[allow(deprecated)]
14017    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14018    where
14019        S: serde::Serializer,
14020    {
14021        use serde::ser::SerializeStruct;
14022        let len = 0;
14023        let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
14024        struct_ser.end()
14025    }
14026}
14027impl<'de> serde::Deserialize<'de> for UnionNode {
14028    #[allow(deprecated)]
14029    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14030    where
14031        D: serde::Deserializer<'de>,
14032    {
14033        const FIELDS: &[&str] = &[
14034        ];
14035
14036        #[allow(clippy::enum_variant_names)]
14037        enum GeneratedField {
14038        }
14039        impl<'de> serde::Deserialize<'de> for GeneratedField {
14040            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14041            where
14042                D: serde::Deserializer<'de>,
14043            {
14044                struct GeneratedVisitor;
14045
14046                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14047                    type Value = GeneratedField;
14048
14049                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14050                        write!(formatter, "expected one of: {:?}", &FIELDS)
14051                    }
14052
14053                    #[allow(unused_variables)]
14054                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14055                    where
14056                        E: serde::de::Error,
14057                    {
14058                            Err(serde::de::Error::unknown_field(value, FIELDS))
14059                    }
14060                }
14061                deserializer.deserialize_identifier(GeneratedVisitor)
14062            }
14063        }
14064        struct GeneratedVisitor;
14065        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14066            type Value = UnionNode;
14067
14068            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14069                formatter.write_str("struct stream_plan.UnionNode")
14070            }
14071
14072            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
14073                where
14074                    V: serde::de::MapAccess<'de>,
14075            {
14076                while map_.next_key::<GeneratedField>()?.is_some() {
14077                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14078                }
14079                Ok(UnionNode {
14080                })
14081            }
14082        }
14083        deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
14084    }
14085}
14086impl serde::Serialize for UpdateMutation {
14087    #[allow(deprecated)]
14088    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14089    where
14090        S: serde::Serializer,
14091    {
14092        use serde::ser::SerializeStruct;
14093        let mut len = 0;
14094        if !self.dispatcher_update.is_empty() {
14095            len += 1;
14096        }
14097        if !self.merge_update.is_empty() {
14098            len += 1;
14099        }
14100        if !self.actor_vnode_bitmap_update.is_empty() {
14101            len += 1;
14102        }
14103        if !self.dropped_actors.is_empty() {
14104            len += 1;
14105        }
14106        if !self.actor_splits.is_empty() {
14107            len += 1;
14108        }
14109        if !self.actor_new_dispatchers.is_empty() {
14110            len += 1;
14111        }
14112        let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
14113        if !self.dispatcher_update.is_empty() {
14114            struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
14115        }
14116        if !self.merge_update.is_empty() {
14117            struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
14118        }
14119        if !self.actor_vnode_bitmap_update.is_empty() {
14120            struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
14121        }
14122        if !self.dropped_actors.is_empty() {
14123            struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
14124        }
14125        if !self.actor_splits.is_empty() {
14126            struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
14127        }
14128        if !self.actor_new_dispatchers.is_empty() {
14129            struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
14130        }
14131        struct_ser.end()
14132    }
14133}
14134impl<'de> serde::Deserialize<'de> for UpdateMutation {
14135    #[allow(deprecated)]
14136    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14137    where
14138        D: serde::Deserializer<'de>,
14139    {
14140        const FIELDS: &[&str] = &[
14141            "dispatcher_update",
14142            "dispatcherUpdate",
14143            "merge_update",
14144            "mergeUpdate",
14145            "actor_vnode_bitmap_update",
14146            "actorVnodeBitmapUpdate",
14147            "dropped_actors",
14148            "droppedActors",
14149            "actor_splits",
14150            "actorSplits",
14151            "actor_new_dispatchers",
14152            "actorNewDispatchers",
14153        ];
14154
14155        #[allow(clippy::enum_variant_names)]
14156        enum GeneratedField {
14157            DispatcherUpdate,
14158            MergeUpdate,
14159            ActorVnodeBitmapUpdate,
14160            DroppedActors,
14161            ActorSplits,
14162            ActorNewDispatchers,
14163        }
14164        impl<'de> serde::Deserialize<'de> for GeneratedField {
14165            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14166            where
14167                D: serde::Deserializer<'de>,
14168            {
14169                struct GeneratedVisitor;
14170
14171                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14172                    type Value = GeneratedField;
14173
14174                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14175                        write!(formatter, "expected one of: {:?}", &FIELDS)
14176                    }
14177
14178                    #[allow(unused_variables)]
14179                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14180                    where
14181                        E: serde::de::Error,
14182                    {
14183                        match value {
14184                            "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
14185                            "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
14186                            "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
14187                            "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
14188                            "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
14189                            "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
14190                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14191                        }
14192                    }
14193                }
14194                deserializer.deserialize_identifier(GeneratedVisitor)
14195            }
14196        }
14197        struct GeneratedVisitor;
14198        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14199            type Value = UpdateMutation;
14200
14201            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14202                formatter.write_str("struct stream_plan.UpdateMutation")
14203            }
14204
14205            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
14206                where
14207                    V: serde::de::MapAccess<'de>,
14208            {
14209                let mut dispatcher_update__ = None;
14210                let mut merge_update__ = None;
14211                let mut actor_vnode_bitmap_update__ = None;
14212                let mut dropped_actors__ = None;
14213                let mut actor_splits__ = None;
14214                let mut actor_new_dispatchers__ = None;
14215                while let Some(k) = map_.next_key()? {
14216                    match k {
14217                        GeneratedField::DispatcherUpdate => {
14218                            if dispatcher_update__.is_some() {
14219                                return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
14220                            }
14221                            dispatcher_update__ = Some(map_.next_value()?);
14222                        }
14223                        GeneratedField::MergeUpdate => {
14224                            if merge_update__.is_some() {
14225                                return Err(serde::de::Error::duplicate_field("mergeUpdate"));
14226                            }
14227                            merge_update__ = Some(map_.next_value()?);
14228                        }
14229                        GeneratedField::ActorVnodeBitmapUpdate => {
14230                            if actor_vnode_bitmap_update__.is_some() {
14231                                return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
14232                            }
14233                            actor_vnode_bitmap_update__ = Some(
14234                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14235                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
14236                            );
14237                        }
14238                        GeneratedField::DroppedActors => {
14239                            if dropped_actors__.is_some() {
14240                                return Err(serde::de::Error::duplicate_field("droppedActors"));
14241                            }
14242                            dropped_actors__ = 
14243                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14244                                    .into_iter().map(|x| x.0).collect())
14245                            ;
14246                        }
14247                        GeneratedField::ActorSplits => {
14248                            if actor_splits__.is_some() {
14249                                return Err(serde::de::Error::duplicate_field("actorSplits"));
14250                            }
14251                            actor_splits__ = Some(
14252                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14253                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
14254                            );
14255                        }
14256                        GeneratedField::ActorNewDispatchers => {
14257                            if actor_new_dispatchers__.is_some() {
14258                                return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
14259                            }
14260                            actor_new_dispatchers__ = Some(
14261                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14262                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
14263                            );
14264                        }
14265                    }
14266                }
14267                Ok(UpdateMutation {
14268                    dispatcher_update: dispatcher_update__.unwrap_or_default(),
14269                    merge_update: merge_update__.unwrap_or_default(),
14270                    actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
14271                    dropped_actors: dropped_actors__.unwrap_or_default(),
14272                    actor_splits: actor_splits__.unwrap_or_default(),
14273                    actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
14274                })
14275            }
14276        }
14277        deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
14278    }
14279}
14280impl serde::Serialize for update_mutation::DispatcherUpdate {
14281    #[allow(deprecated)]
14282    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14283    where
14284        S: serde::Serializer,
14285    {
14286        use serde::ser::SerializeStruct;
14287        let mut len = 0;
14288        if self.actor_id != 0 {
14289            len += 1;
14290        }
14291        if self.dispatcher_id != 0 {
14292            len += 1;
14293        }
14294        if self.hash_mapping.is_some() {
14295            len += 1;
14296        }
14297        if !self.added_downstream_actor_id.is_empty() {
14298            len += 1;
14299        }
14300        if !self.removed_downstream_actor_id.is_empty() {
14301            len += 1;
14302        }
14303        let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
14304        if self.actor_id != 0 {
14305            struct_ser.serialize_field("actorId", &self.actor_id)?;
14306        }
14307        if self.dispatcher_id != 0 {
14308            #[allow(clippy::needless_borrow)]
14309            #[allow(clippy::needless_borrows_for_generic_args)]
14310            struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
14311        }
14312        if let Some(v) = self.hash_mapping.as_ref() {
14313            struct_ser.serialize_field("hashMapping", v)?;
14314        }
14315        if !self.added_downstream_actor_id.is_empty() {
14316            struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
14317        }
14318        if !self.removed_downstream_actor_id.is_empty() {
14319            struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
14320        }
14321        struct_ser.end()
14322    }
14323}
14324impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
14325    #[allow(deprecated)]
14326    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14327    where
14328        D: serde::Deserializer<'de>,
14329    {
14330        const FIELDS: &[&str] = &[
14331            "actor_id",
14332            "actorId",
14333            "dispatcher_id",
14334            "dispatcherId",
14335            "hash_mapping",
14336            "hashMapping",
14337            "added_downstream_actor_id",
14338            "addedDownstreamActorId",
14339            "removed_downstream_actor_id",
14340            "removedDownstreamActorId",
14341        ];
14342
14343        #[allow(clippy::enum_variant_names)]
14344        enum GeneratedField {
14345            ActorId,
14346            DispatcherId,
14347            HashMapping,
14348            AddedDownstreamActorId,
14349            RemovedDownstreamActorId,
14350        }
14351        impl<'de> serde::Deserialize<'de> for GeneratedField {
14352            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14353            where
14354                D: serde::Deserializer<'de>,
14355            {
14356                struct GeneratedVisitor;
14357
14358                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14359                    type Value = GeneratedField;
14360
14361                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14362                        write!(formatter, "expected one of: {:?}", &FIELDS)
14363                    }
14364
14365                    #[allow(unused_variables)]
14366                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14367                    where
14368                        E: serde::de::Error,
14369                    {
14370                        match value {
14371                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
14372                            "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
14373                            "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
14374                            "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
14375                            "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
14376                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14377                        }
14378                    }
14379                }
14380                deserializer.deserialize_identifier(GeneratedVisitor)
14381            }
14382        }
14383        struct GeneratedVisitor;
14384        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14385            type Value = update_mutation::DispatcherUpdate;
14386
14387            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14388                formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
14389            }
14390
14391            fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
14392                where
14393                    V: serde::de::MapAccess<'de>,
14394            {
14395                let mut actor_id__ = None;
14396                let mut dispatcher_id__ = None;
14397                let mut hash_mapping__ = None;
14398                let mut added_downstream_actor_id__ = None;
14399                let mut removed_downstream_actor_id__ = None;
14400                while let Some(k) = map_.next_key()? {
14401                    match k {
14402                        GeneratedField::ActorId => {
14403                            if actor_id__.is_some() {
14404                                return Err(serde::de::Error::duplicate_field("actorId"));
14405                            }
14406                            actor_id__ = 
14407                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14408                            ;
14409                        }
14410                        GeneratedField::DispatcherId => {
14411                            if dispatcher_id__.is_some() {
14412                                return Err(serde::de::Error::duplicate_field("dispatcherId"));
14413                            }
14414                            dispatcher_id__ = 
14415                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14416                            ;
14417                        }
14418                        GeneratedField::HashMapping => {
14419                            if hash_mapping__.is_some() {
14420                                return Err(serde::de::Error::duplicate_field("hashMapping"));
14421                            }
14422                            hash_mapping__ = map_.next_value()?;
14423                        }
14424                        GeneratedField::AddedDownstreamActorId => {
14425                            if added_downstream_actor_id__.is_some() {
14426                                return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
14427                            }
14428                            added_downstream_actor_id__ = 
14429                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14430                                    .into_iter().map(|x| x.0).collect())
14431                            ;
14432                        }
14433                        GeneratedField::RemovedDownstreamActorId => {
14434                            if removed_downstream_actor_id__.is_some() {
14435                                return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
14436                            }
14437                            removed_downstream_actor_id__ = 
14438                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14439                                    .into_iter().map(|x| x.0).collect())
14440                            ;
14441                        }
14442                    }
14443                }
14444                Ok(update_mutation::DispatcherUpdate {
14445                    actor_id: actor_id__.unwrap_or_default(),
14446                    dispatcher_id: dispatcher_id__.unwrap_or_default(),
14447                    hash_mapping: hash_mapping__,
14448                    added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
14449                    removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
14450                })
14451            }
14452        }
14453        deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
14454    }
14455}
14456impl serde::Serialize for update_mutation::MergeUpdate {
14457    #[allow(deprecated)]
14458    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14459    where
14460        S: serde::Serializer,
14461    {
14462        use serde::ser::SerializeStruct;
14463        let mut len = 0;
14464        if self.actor_id != 0 {
14465            len += 1;
14466        }
14467        if self.upstream_fragment_id != 0 {
14468            len += 1;
14469        }
14470        if self.new_upstream_fragment_id.is_some() {
14471            len += 1;
14472        }
14473        if !self.added_upstream_actors.is_empty() {
14474            len += 1;
14475        }
14476        if !self.removed_upstream_actor_id.is_empty() {
14477            len += 1;
14478        }
14479        let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
14480        if self.actor_id != 0 {
14481            struct_ser.serialize_field("actorId", &self.actor_id)?;
14482        }
14483        if self.upstream_fragment_id != 0 {
14484            struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
14485        }
14486        if let Some(v) = self.new_upstream_fragment_id.as_ref() {
14487            struct_ser.serialize_field("newUpstreamFragmentId", v)?;
14488        }
14489        if !self.added_upstream_actors.is_empty() {
14490            struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
14491        }
14492        if !self.removed_upstream_actor_id.is_empty() {
14493            struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
14494        }
14495        struct_ser.end()
14496    }
14497}
14498impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
14499    #[allow(deprecated)]
14500    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14501    where
14502        D: serde::Deserializer<'de>,
14503    {
14504        const FIELDS: &[&str] = &[
14505            "actor_id",
14506            "actorId",
14507            "upstream_fragment_id",
14508            "upstreamFragmentId",
14509            "new_upstream_fragment_id",
14510            "newUpstreamFragmentId",
14511            "added_upstream_actors",
14512            "addedUpstreamActors",
14513            "removed_upstream_actor_id",
14514            "removedUpstreamActorId",
14515        ];
14516
14517        #[allow(clippy::enum_variant_names)]
14518        enum GeneratedField {
14519            ActorId,
14520            UpstreamFragmentId,
14521            NewUpstreamFragmentId,
14522            AddedUpstreamActors,
14523            RemovedUpstreamActorId,
14524        }
14525        impl<'de> serde::Deserialize<'de> for GeneratedField {
14526            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14527            where
14528                D: serde::Deserializer<'de>,
14529            {
14530                struct GeneratedVisitor;
14531
14532                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14533                    type Value = GeneratedField;
14534
14535                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14536                        write!(formatter, "expected one of: {:?}", &FIELDS)
14537                    }
14538
14539                    #[allow(unused_variables)]
14540                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14541                    where
14542                        E: serde::de::Error,
14543                    {
14544                        match value {
14545                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
14546                            "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
14547                            "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
14548                            "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
14549                            "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
14550                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14551                        }
14552                    }
14553                }
14554                deserializer.deserialize_identifier(GeneratedVisitor)
14555            }
14556        }
14557        struct GeneratedVisitor;
14558        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14559            type Value = update_mutation::MergeUpdate;
14560
14561            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14562                formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
14563            }
14564
14565            fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
14566                where
14567                    V: serde::de::MapAccess<'de>,
14568            {
14569                let mut actor_id__ = None;
14570                let mut upstream_fragment_id__ = None;
14571                let mut new_upstream_fragment_id__ = None;
14572                let mut added_upstream_actors__ = None;
14573                let mut removed_upstream_actor_id__ = None;
14574                while let Some(k) = map_.next_key()? {
14575                    match k {
14576                        GeneratedField::ActorId => {
14577                            if actor_id__.is_some() {
14578                                return Err(serde::de::Error::duplicate_field("actorId"));
14579                            }
14580                            actor_id__ = 
14581                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14582                            ;
14583                        }
14584                        GeneratedField::UpstreamFragmentId => {
14585                            if upstream_fragment_id__.is_some() {
14586                                return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
14587                            }
14588                            upstream_fragment_id__ = 
14589                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14590                            ;
14591                        }
14592                        GeneratedField::NewUpstreamFragmentId => {
14593                            if new_upstream_fragment_id__.is_some() {
14594                                return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
14595                            }
14596                            new_upstream_fragment_id__ = 
14597                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14598                            ;
14599                        }
14600                        GeneratedField::AddedUpstreamActors => {
14601                            if added_upstream_actors__.is_some() {
14602                                return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
14603                            }
14604                            added_upstream_actors__ = Some(map_.next_value()?);
14605                        }
14606                        GeneratedField::RemovedUpstreamActorId => {
14607                            if removed_upstream_actor_id__.is_some() {
14608                                return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
14609                            }
14610                            removed_upstream_actor_id__ = 
14611                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14612                                    .into_iter().map(|x| x.0).collect())
14613                            ;
14614                        }
14615                    }
14616                }
14617                Ok(update_mutation::MergeUpdate {
14618                    actor_id: actor_id__.unwrap_or_default(),
14619                    upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
14620                    new_upstream_fragment_id: new_upstream_fragment_id__,
14621                    added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
14622                    removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
14623                })
14624            }
14625        }
14626        deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
14627    }
14628}
14629impl serde::Serialize for ValuesNode {
14630    #[allow(deprecated)]
14631    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14632    where
14633        S: serde::Serializer,
14634    {
14635        use serde::ser::SerializeStruct;
14636        let mut len = 0;
14637        if !self.tuples.is_empty() {
14638            len += 1;
14639        }
14640        if !self.fields.is_empty() {
14641            len += 1;
14642        }
14643        let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
14644        if !self.tuples.is_empty() {
14645            struct_ser.serialize_field("tuples", &self.tuples)?;
14646        }
14647        if !self.fields.is_empty() {
14648            struct_ser.serialize_field("fields", &self.fields)?;
14649        }
14650        struct_ser.end()
14651    }
14652}
14653impl<'de> serde::Deserialize<'de> for ValuesNode {
14654    #[allow(deprecated)]
14655    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14656    where
14657        D: serde::Deserializer<'de>,
14658    {
14659        const FIELDS: &[&str] = &[
14660            "tuples",
14661            "fields",
14662        ];
14663
14664        #[allow(clippy::enum_variant_names)]
14665        enum GeneratedField {
14666            Tuples,
14667            Fields,
14668        }
14669        impl<'de> serde::Deserialize<'de> for GeneratedField {
14670            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14671            where
14672                D: serde::Deserializer<'de>,
14673            {
14674                struct GeneratedVisitor;
14675
14676                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14677                    type Value = GeneratedField;
14678
14679                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14680                        write!(formatter, "expected one of: {:?}", &FIELDS)
14681                    }
14682
14683                    #[allow(unused_variables)]
14684                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14685                    where
14686                        E: serde::de::Error,
14687                    {
14688                        match value {
14689                            "tuples" => Ok(GeneratedField::Tuples),
14690                            "fields" => Ok(GeneratedField::Fields),
14691                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14692                        }
14693                    }
14694                }
14695                deserializer.deserialize_identifier(GeneratedVisitor)
14696            }
14697        }
14698        struct GeneratedVisitor;
14699        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14700            type Value = ValuesNode;
14701
14702            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14703                formatter.write_str("struct stream_plan.ValuesNode")
14704            }
14705
14706            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
14707                where
14708                    V: serde::de::MapAccess<'de>,
14709            {
14710                let mut tuples__ = None;
14711                let mut fields__ = None;
14712                while let Some(k) = map_.next_key()? {
14713                    match k {
14714                        GeneratedField::Tuples => {
14715                            if tuples__.is_some() {
14716                                return Err(serde::de::Error::duplicate_field("tuples"));
14717                            }
14718                            tuples__ = Some(map_.next_value()?);
14719                        }
14720                        GeneratedField::Fields => {
14721                            if fields__.is_some() {
14722                                return Err(serde::de::Error::duplicate_field("fields"));
14723                            }
14724                            fields__ = Some(map_.next_value()?);
14725                        }
14726                    }
14727                }
14728                Ok(ValuesNode {
14729                    tuples: tuples__.unwrap_or_default(),
14730                    fields: fields__.unwrap_or_default(),
14731                })
14732            }
14733        }
14734        deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
14735    }
14736}
14737impl serde::Serialize for values_node::ExprTuple {
14738    #[allow(deprecated)]
14739    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14740    where
14741        S: serde::Serializer,
14742    {
14743        use serde::ser::SerializeStruct;
14744        let mut len = 0;
14745        if !self.cells.is_empty() {
14746            len += 1;
14747        }
14748        let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
14749        if !self.cells.is_empty() {
14750            struct_ser.serialize_field("cells", &self.cells)?;
14751        }
14752        struct_ser.end()
14753    }
14754}
14755impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
14756    #[allow(deprecated)]
14757    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14758    where
14759        D: serde::Deserializer<'de>,
14760    {
14761        const FIELDS: &[&str] = &[
14762            "cells",
14763        ];
14764
14765        #[allow(clippy::enum_variant_names)]
14766        enum GeneratedField {
14767            Cells,
14768        }
14769        impl<'de> serde::Deserialize<'de> for GeneratedField {
14770            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14771            where
14772                D: serde::Deserializer<'de>,
14773            {
14774                struct GeneratedVisitor;
14775
14776                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14777                    type Value = GeneratedField;
14778
14779                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14780                        write!(formatter, "expected one of: {:?}", &FIELDS)
14781                    }
14782
14783                    #[allow(unused_variables)]
14784                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14785                    where
14786                        E: serde::de::Error,
14787                    {
14788                        match value {
14789                            "cells" => Ok(GeneratedField::Cells),
14790                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14791                        }
14792                    }
14793                }
14794                deserializer.deserialize_identifier(GeneratedVisitor)
14795            }
14796        }
14797        struct GeneratedVisitor;
14798        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14799            type Value = values_node::ExprTuple;
14800
14801            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14802                formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
14803            }
14804
14805            fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
14806                where
14807                    V: serde::de::MapAccess<'de>,
14808            {
14809                let mut cells__ = None;
14810                while let Some(k) = map_.next_key()? {
14811                    match k {
14812                        GeneratedField::Cells => {
14813                            if cells__.is_some() {
14814                                return Err(serde::de::Error::duplicate_field("cells"));
14815                            }
14816                            cells__ = Some(map_.next_value()?);
14817                        }
14818                    }
14819                }
14820                Ok(values_node::ExprTuple {
14821                    cells: cells__.unwrap_or_default(),
14822                })
14823            }
14824        }
14825        deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
14826    }
14827}
14828impl serde::Serialize for Watermark {
14829    #[allow(deprecated)]
14830    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14831    where
14832        S: serde::Serializer,
14833    {
14834        use serde::ser::SerializeStruct;
14835        let mut len = 0;
14836        if self.column.is_some() {
14837            len += 1;
14838        }
14839        if self.val.is_some() {
14840            len += 1;
14841        }
14842        let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
14843        if let Some(v) = self.column.as_ref() {
14844            struct_ser.serialize_field("column", v)?;
14845        }
14846        if let Some(v) = self.val.as_ref() {
14847            struct_ser.serialize_field("val", v)?;
14848        }
14849        struct_ser.end()
14850    }
14851}
14852impl<'de> serde::Deserialize<'de> for Watermark {
14853    #[allow(deprecated)]
14854    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14855    where
14856        D: serde::Deserializer<'de>,
14857    {
14858        const FIELDS: &[&str] = &[
14859            "column",
14860            "val",
14861        ];
14862
14863        #[allow(clippy::enum_variant_names)]
14864        enum GeneratedField {
14865            Column,
14866            Val,
14867        }
14868        impl<'de> serde::Deserialize<'de> for GeneratedField {
14869            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14870            where
14871                D: serde::Deserializer<'de>,
14872            {
14873                struct GeneratedVisitor;
14874
14875                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14876                    type Value = GeneratedField;
14877
14878                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14879                        write!(formatter, "expected one of: {:?}", &FIELDS)
14880                    }
14881
14882                    #[allow(unused_variables)]
14883                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14884                    where
14885                        E: serde::de::Error,
14886                    {
14887                        match value {
14888                            "column" => Ok(GeneratedField::Column),
14889                            "val" => Ok(GeneratedField::Val),
14890                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14891                        }
14892                    }
14893                }
14894                deserializer.deserialize_identifier(GeneratedVisitor)
14895            }
14896        }
14897        struct GeneratedVisitor;
14898        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14899            type Value = Watermark;
14900
14901            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14902                formatter.write_str("struct stream_plan.Watermark")
14903            }
14904
14905            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
14906                where
14907                    V: serde::de::MapAccess<'de>,
14908            {
14909                let mut column__ = None;
14910                let mut val__ = None;
14911                while let Some(k) = map_.next_key()? {
14912                    match k {
14913                        GeneratedField::Column => {
14914                            if column__.is_some() {
14915                                return Err(serde::de::Error::duplicate_field("column"));
14916                            }
14917                            column__ = map_.next_value()?;
14918                        }
14919                        GeneratedField::Val => {
14920                            if val__.is_some() {
14921                                return Err(serde::de::Error::duplicate_field("val"));
14922                            }
14923                            val__ = map_.next_value()?;
14924                        }
14925                    }
14926                }
14927                Ok(Watermark {
14928                    column: column__,
14929                    val: val__,
14930                })
14931            }
14932        }
14933        deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
14934    }
14935}
14936impl serde::Serialize for WatermarkFilterNode {
14937    #[allow(deprecated)]
14938    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14939    where
14940        S: serde::Serializer,
14941    {
14942        use serde::ser::SerializeStruct;
14943        let mut len = 0;
14944        if !self.watermark_descs.is_empty() {
14945            len += 1;
14946        }
14947        if !self.tables.is_empty() {
14948            len += 1;
14949        }
14950        let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
14951        if !self.watermark_descs.is_empty() {
14952            struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
14953        }
14954        if !self.tables.is_empty() {
14955            struct_ser.serialize_field("tables", &self.tables)?;
14956        }
14957        struct_ser.end()
14958    }
14959}
14960impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
14961    #[allow(deprecated)]
14962    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14963    where
14964        D: serde::Deserializer<'de>,
14965    {
14966        const FIELDS: &[&str] = &[
14967            "watermark_descs",
14968            "watermarkDescs",
14969            "tables",
14970        ];
14971
14972        #[allow(clippy::enum_variant_names)]
14973        enum GeneratedField {
14974            WatermarkDescs,
14975            Tables,
14976        }
14977        impl<'de> serde::Deserialize<'de> for GeneratedField {
14978            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14979            where
14980                D: serde::Deserializer<'de>,
14981            {
14982                struct GeneratedVisitor;
14983
14984                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14985                    type Value = GeneratedField;
14986
14987                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14988                        write!(formatter, "expected one of: {:?}", &FIELDS)
14989                    }
14990
14991                    #[allow(unused_variables)]
14992                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14993                    where
14994                        E: serde::de::Error,
14995                    {
14996                        match value {
14997                            "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
14998                            "tables" => Ok(GeneratedField::Tables),
14999                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15000                        }
15001                    }
15002                }
15003                deserializer.deserialize_identifier(GeneratedVisitor)
15004            }
15005        }
15006        struct GeneratedVisitor;
15007        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15008            type Value = WatermarkFilterNode;
15009
15010            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15011                formatter.write_str("struct stream_plan.WatermarkFilterNode")
15012            }
15013
15014            fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
15015                where
15016                    V: serde::de::MapAccess<'de>,
15017            {
15018                let mut watermark_descs__ = None;
15019                let mut tables__ = None;
15020                while let Some(k) = map_.next_key()? {
15021                    match k {
15022                        GeneratedField::WatermarkDescs => {
15023                            if watermark_descs__.is_some() {
15024                                return Err(serde::de::Error::duplicate_field("watermarkDescs"));
15025                            }
15026                            watermark_descs__ = Some(map_.next_value()?);
15027                        }
15028                        GeneratedField::Tables => {
15029                            if tables__.is_some() {
15030                                return Err(serde::de::Error::duplicate_field("tables"));
15031                            }
15032                            tables__ = Some(map_.next_value()?);
15033                        }
15034                    }
15035                }
15036                Ok(WatermarkFilterNode {
15037                    watermark_descs: watermark_descs__.unwrap_or_default(),
15038                    tables: tables__.unwrap_or_default(),
15039                })
15040            }
15041        }
15042        deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
15043    }
15044}