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        let mut struct_ser = serializer.serialize_struct("stream_plan.AsOfJoinNode", len)?;
1035        if self.join_type != 0 {
1036            let v = super::plan_common::AsOfJoinType::try_from(self.join_type)
1037                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
1038            struct_ser.serialize_field("joinType", &v)?;
1039        }
1040        if !self.left_key.is_empty() {
1041            struct_ser.serialize_field("leftKey", &self.left_key)?;
1042        }
1043        if !self.right_key.is_empty() {
1044            struct_ser.serialize_field("rightKey", &self.right_key)?;
1045        }
1046        if let Some(v) = self.left_table.as_ref() {
1047            struct_ser.serialize_field("leftTable", v)?;
1048        }
1049        if let Some(v) = self.right_table.as_ref() {
1050            struct_ser.serialize_field("rightTable", v)?;
1051        }
1052        if !self.output_indices.is_empty() {
1053            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
1054        }
1055        if !self.left_deduped_input_pk_indices.is_empty() {
1056            struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
1057        }
1058        if !self.right_deduped_input_pk_indices.is_empty() {
1059            struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
1060        }
1061        if !self.null_safe.is_empty() {
1062            struct_ser.serialize_field("nullSafe", &self.null_safe)?;
1063        }
1064        if let Some(v) = self.asof_desc.as_ref() {
1065            struct_ser.serialize_field("asofDesc", v)?;
1066        }
1067        struct_ser.end()
1068    }
1069}
1070impl<'de> serde::Deserialize<'de> for AsOfJoinNode {
1071    #[allow(deprecated)]
1072    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1073    where
1074        D: serde::Deserializer<'de>,
1075    {
1076        const FIELDS: &[&str] = &[
1077            "join_type",
1078            "joinType",
1079            "left_key",
1080            "leftKey",
1081            "right_key",
1082            "rightKey",
1083            "left_table",
1084            "leftTable",
1085            "right_table",
1086            "rightTable",
1087            "output_indices",
1088            "outputIndices",
1089            "left_deduped_input_pk_indices",
1090            "leftDedupedInputPkIndices",
1091            "right_deduped_input_pk_indices",
1092            "rightDedupedInputPkIndices",
1093            "null_safe",
1094            "nullSafe",
1095            "asof_desc",
1096            "asofDesc",
1097        ];
1098
1099        #[allow(clippy::enum_variant_names)]
1100        enum GeneratedField {
1101            JoinType,
1102            LeftKey,
1103            RightKey,
1104            LeftTable,
1105            RightTable,
1106            OutputIndices,
1107            LeftDedupedInputPkIndices,
1108            RightDedupedInputPkIndices,
1109            NullSafe,
1110            AsofDesc,
1111        }
1112        impl<'de> serde::Deserialize<'de> for GeneratedField {
1113            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1114            where
1115                D: serde::Deserializer<'de>,
1116            {
1117                struct GeneratedVisitor;
1118
1119                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1120                    type Value = GeneratedField;
1121
1122                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1123                        write!(formatter, "expected one of: {:?}", &FIELDS)
1124                    }
1125
1126                    #[allow(unused_variables)]
1127                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1128                    where
1129                        E: serde::de::Error,
1130                    {
1131                        match value {
1132                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
1133                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
1134                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
1135                            "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
1136                            "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
1137                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
1138                            "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
1139                            "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
1140                            "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
1141                            "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
1142                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1143                        }
1144                    }
1145                }
1146                deserializer.deserialize_identifier(GeneratedVisitor)
1147            }
1148        }
1149        struct GeneratedVisitor;
1150        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1151            type Value = AsOfJoinNode;
1152
1153            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1154                formatter.write_str("struct stream_plan.AsOfJoinNode")
1155            }
1156
1157            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinNode, V::Error>
1158                where
1159                    V: serde::de::MapAccess<'de>,
1160            {
1161                let mut join_type__ = None;
1162                let mut left_key__ = None;
1163                let mut right_key__ = None;
1164                let mut left_table__ = None;
1165                let mut right_table__ = None;
1166                let mut output_indices__ = None;
1167                let mut left_deduped_input_pk_indices__ = None;
1168                let mut right_deduped_input_pk_indices__ = None;
1169                let mut null_safe__ = None;
1170                let mut asof_desc__ = None;
1171                while let Some(k) = map_.next_key()? {
1172                    match k {
1173                        GeneratedField::JoinType => {
1174                            if join_type__.is_some() {
1175                                return Err(serde::de::Error::duplicate_field("joinType"));
1176                            }
1177                            join_type__ = Some(map_.next_value::<super::plan_common::AsOfJoinType>()? as i32);
1178                        }
1179                        GeneratedField::LeftKey => {
1180                            if left_key__.is_some() {
1181                                return Err(serde::de::Error::duplicate_field("leftKey"));
1182                            }
1183                            left_key__ = 
1184                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1185                                    .into_iter().map(|x| x.0).collect())
1186                            ;
1187                        }
1188                        GeneratedField::RightKey => {
1189                            if right_key__.is_some() {
1190                                return Err(serde::de::Error::duplicate_field("rightKey"));
1191                            }
1192                            right_key__ = 
1193                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1194                                    .into_iter().map(|x| x.0).collect())
1195                            ;
1196                        }
1197                        GeneratedField::LeftTable => {
1198                            if left_table__.is_some() {
1199                                return Err(serde::de::Error::duplicate_field("leftTable"));
1200                            }
1201                            left_table__ = map_.next_value()?;
1202                        }
1203                        GeneratedField::RightTable => {
1204                            if right_table__.is_some() {
1205                                return Err(serde::de::Error::duplicate_field("rightTable"));
1206                            }
1207                            right_table__ = map_.next_value()?;
1208                        }
1209                        GeneratedField::OutputIndices => {
1210                            if output_indices__.is_some() {
1211                                return Err(serde::de::Error::duplicate_field("outputIndices"));
1212                            }
1213                            output_indices__ = 
1214                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1215                                    .into_iter().map(|x| x.0).collect())
1216                            ;
1217                        }
1218                        GeneratedField::LeftDedupedInputPkIndices => {
1219                            if left_deduped_input_pk_indices__.is_some() {
1220                                return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
1221                            }
1222                            left_deduped_input_pk_indices__ = 
1223                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1224                                    .into_iter().map(|x| x.0).collect())
1225                            ;
1226                        }
1227                        GeneratedField::RightDedupedInputPkIndices => {
1228                            if right_deduped_input_pk_indices__.is_some() {
1229                                return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
1230                            }
1231                            right_deduped_input_pk_indices__ = 
1232                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1233                                    .into_iter().map(|x| x.0).collect())
1234                            ;
1235                        }
1236                        GeneratedField::NullSafe => {
1237                            if null_safe__.is_some() {
1238                                return Err(serde::de::Error::duplicate_field("nullSafe"));
1239                            }
1240                            null_safe__ = Some(map_.next_value()?);
1241                        }
1242                        GeneratedField::AsofDesc => {
1243                            if asof_desc__.is_some() {
1244                                return Err(serde::de::Error::duplicate_field("asofDesc"));
1245                            }
1246                            asof_desc__ = map_.next_value()?;
1247                        }
1248                    }
1249                }
1250                Ok(AsOfJoinNode {
1251                    join_type: join_type__.unwrap_or_default(),
1252                    left_key: left_key__.unwrap_or_default(),
1253                    right_key: right_key__.unwrap_or_default(),
1254                    left_table: left_table__,
1255                    right_table: right_table__,
1256                    output_indices: output_indices__.unwrap_or_default(),
1257                    left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
1258                    right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
1259                    null_safe: null_safe__.unwrap_or_default(),
1260                    asof_desc: asof_desc__,
1261                })
1262            }
1263        }
1264        deserializer.deserialize_struct("stream_plan.AsOfJoinNode", FIELDS, GeneratedVisitor)
1265    }
1266}
1267impl serde::Serialize for BackfillOrder {
1268    #[allow(deprecated)]
1269    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1270    where
1271        S: serde::Serializer,
1272    {
1273        use serde::ser::SerializeStruct;
1274        let mut len = 0;
1275        if !self.order.is_empty() {
1276            len += 1;
1277        }
1278        let mut struct_ser = serializer.serialize_struct("stream_plan.BackfillOrder", len)?;
1279        if !self.order.is_empty() {
1280            struct_ser.serialize_field("order", &self.order)?;
1281        }
1282        struct_ser.end()
1283    }
1284}
1285impl<'de> serde::Deserialize<'de> for BackfillOrder {
1286    #[allow(deprecated)]
1287    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1288    where
1289        D: serde::Deserializer<'de>,
1290    {
1291        const FIELDS: &[&str] = &[
1292            "order",
1293        ];
1294
1295        #[allow(clippy::enum_variant_names)]
1296        enum GeneratedField {
1297            Order,
1298        }
1299        impl<'de> serde::Deserialize<'de> for GeneratedField {
1300            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1301            where
1302                D: serde::Deserializer<'de>,
1303            {
1304                struct GeneratedVisitor;
1305
1306                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1307                    type Value = GeneratedField;
1308
1309                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1310                        write!(formatter, "expected one of: {:?}", &FIELDS)
1311                    }
1312
1313                    #[allow(unused_variables)]
1314                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1315                    where
1316                        E: serde::de::Error,
1317                    {
1318                        match value {
1319                            "order" => Ok(GeneratedField::Order),
1320                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1321                        }
1322                    }
1323                }
1324                deserializer.deserialize_identifier(GeneratedVisitor)
1325            }
1326        }
1327        struct GeneratedVisitor;
1328        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1329            type Value = BackfillOrder;
1330
1331            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1332                formatter.write_str("struct stream_plan.BackfillOrder")
1333            }
1334
1335            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackfillOrder, V::Error>
1336                where
1337                    V: serde::de::MapAccess<'de>,
1338            {
1339                let mut order__ = None;
1340                while let Some(k) = map_.next_key()? {
1341                    match k {
1342                        GeneratedField::Order => {
1343                            if order__.is_some() {
1344                                return Err(serde::de::Error::duplicate_field("order"));
1345                            }
1346                            order__ = Some(
1347                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1348                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
1349                            );
1350                        }
1351                    }
1352                }
1353                Ok(BackfillOrder {
1354                    order: order__.unwrap_or_default(),
1355                })
1356            }
1357        }
1358        deserializer.deserialize_struct("stream_plan.BackfillOrder", FIELDS, GeneratedVisitor)
1359    }
1360}
1361impl serde::Serialize for Barrier {
1362    #[allow(deprecated)]
1363    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1364    where
1365        S: serde::Serializer,
1366    {
1367        use serde::ser::SerializeStruct;
1368        let mut len = 0;
1369        if self.epoch.is_some() {
1370            len += 1;
1371        }
1372        if self.mutation.is_some() {
1373            len += 1;
1374        }
1375        if !self.tracing_context.is_empty() {
1376            len += 1;
1377        }
1378        if self.kind != 0 {
1379            len += 1;
1380        }
1381        if !self.passed_actors.is_empty() {
1382            len += 1;
1383        }
1384        let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1385        if let Some(v) = self.epoch.as_ref() {
1386            struct_ser.serialize_field("epoch", v)?;
1387        }
1388        if let Some(v) = self.mutation.as_ref() {
1389            struct_ser.serialize_field("mutation", v)?;
1390        }
1391        if !self.tracing_context.is_empty() {
1392            struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1393        }
1394        if self.kind != 0 {
1395            let v = barrier::BarrierKind::try_from(self.kind)
1396                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1397            struct_ser.serialize_field("kind", &v)?;
1398        }
1399        if !self.passed_actors.is_empty() {
1400            struct_ser.serialize_field("passedActors", &self.passed_actors)?;
1401        }
1402        struct_ser.end()
1403    }
1404}
1405impl<'de> serde::Deserialize<'de> for Barrier {
1406    #[allow(deprecated)]
1407    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1408    where
1409        D: serde::Deserializer<'de>,
1410    {
1411        const FIELDS: &[&str] = &[
1412            "epoch",
1413            "mutation",
1414            "tracing_context",
1415            "tracingContext",
1416            "kind",
1417            "passed_actors",
1418            "passedActors",
1419        ];
1420
1421        #[allow(clippy::enum_variant_names)]
1422        enum GeneratedField {
1423            Epoch,
1424            Mutation,
1425            TracingContext,
1426            Kind,
1427            PassedActors,
1428        }
1429        impl<'de> serde::Deserialize<'de> for GeneratedField {
1430            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1431            where
1432                D: serde::Deserializer<'de>,
1433            {
1434                struct GeneratedVisitor;
1435
1436                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1437                    type Value = GeneratedField;
1438
1439                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1440                        write!(formatter, "expected one of: {:?}", &FIELDS)
1441                    }
1442
1443                    #[allow(unused_variables)]
1444                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1445                    where
1446                        E: serde::de::Error,
1447                    {
1448                        match value {
1449                            "epoch" => Ok(GeneratedField::Epoch),
1450                            "mutation" => Ok(GeneratedField::Mutation),
1451                            "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1452                            "kind" => Ok(GeneratedField::Kind),
1453                            "passedActors" | "passed_actors" => Ok(GeneratedField::PassedActors),
1454                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1455                        }
1456                    }
1457                }
1458                deserializer.deserialize_identifier(GeneratedVisitor)
1459            }
1460        }
1461        struct GeneratedVisitor;
1462        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1463            type Value = Barrier;
1464
1465            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1466                formatter.write_str("struct stream_plan.Barrier")
1467            }
1468
1469            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1470                where
1471                    V: serde::de::MapAccess<'de>,
1472            {
1473                let mut epoch__ = None;
1474                let mut mutation__ = None;
1475                let mut tracing_context__ = None;
1476                let mut kind__ = None;
1477                let mut passed_actors__ = None;
1478                while let Some(k) = map_.next_key()? {
1479                    match k {
1480                        GeneratedField::Epoch => {
1481                            if epoch__.is_some() {
1482                                return Err(serde::de::Error::duplicate_field("epoch"));
1483                            }
1484                            epoch__ = map_.next_value()?;
1485                        }
1486                        GeneratedField::Mutation => {
1487                            if mutation__.is_some() {
1488                                return Err(serde::de::Error::duplicate_field("mutation"));
1489                            }
1490                            mutation__ = map_.next_value()?;
1491                        }
1492                        GeneratedField::TracingContext => {
1493                            if tracing_context__.is_some() {
1494                                return Err(serde::de::Error::duplicate_field("tracingContext"));
1495                            }
1496                            tracing_context__ = Some(
1497                                map_.next_value::<std::collections::HashMap<_, _>>()?
1498                            );
1499                        }
1500                        GeneratedField::Kind => {
1501                            if kind__.is_some() {
1502                                return Err(serde::de::Error::duplicate_field("kind"));
1503                            }
1504                            kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1505                        }
1506                        GeneratedField::PassedActors => {
1507                            if passed_actors__.is_some() {
1508                                return Err(serde::de::Error::duplicate_field("passedActors"));
1509                            }
1510                            passed_actors__ = 
1511                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1512                                    .into_iter().map(|x| x.0).collect())
1513                            ;
1514                        }
1515                    }
1516                }
1517                Ok(Barrier {
1518                    epoch: epoch__,
1519                    mutation: mutation__,
1520                    tracing_context: tracing_context__.unwrap_or_default(),
1521                    kind: kind__.unwrap_or_default(),
1522                    passed_actors: passed_actors__.unwrap_or_default(),
1523                })
1524            }
1525        }
1526        deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1527    }
1528}
1529impl serde::Serialize for barrier::BarrierKind {
1530    #[allow(deprecated)]
1531    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1532    where
1533        S: serde::Serializer,
1534    {
1535        let variant = match self {
1536            Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1537            Self::Initial => "BARRIER_KIND_INITIAL",
1538            Self::Barrier => "BARRIER_KIND_BARRIER",
1539            Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1540        };
1541        serializer.serialize_str(variant)
1542    }
1543}
1544impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1545    #[allow(deprecated)]
1546    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1547    where
1548        D: serde::Deserializer<'de>,
1549    {
1550        const FIELDS: &[&str] = &[
1551            "BARRIER_KIND_UNSPECIFIED",
1552            "BARRIER_KIND_INITIAL",
1553            "BARRIER_KIND_BARRIER",
1554            "BARRIER_KIND_CHECKPOINT",
1555        ];
1556
1557        struct GeneratedVisitor;
1558
1559        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1560            type Value = barrier::BarrierKind;
1561
1562            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1563                write!(formatter, "expected one of: {:?}", &FIELDS)
1564            }
1565
1566            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1567            where
1568                E: serde::de::Error,
1569            {
1570                i32::try_from(v)
1571                    .ok()
1572                    .and_then(|x| x.try_into().ok())
1573                    .ok_or_else(|| {
1574                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1575                    })
1576            }
1577
1578            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1579            where
1580                E: serde::de::Error,
1581            {
1582                i32::try_from(v)
1583                    .ok()
1584                    .and_then(|x| x.try_into().ok())
1585                    .ok_or_else(|| {
1586                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1587                    })
1588            }
1589
1590            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1591            where
1592                E: serde::de::Error,
1593            {
1594                match value {
1595                    "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1596                    "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1597                    "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1598                    "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1599                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1600                }
1601            }
1602        }
1603        deserializer.deserialize_any(GeneratedVisitor)
1604    }
1605}
1606impl serde::Serialize for BarrierMutation {
1607    #[allow(deprecated)]
1608    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1609    where
1610        S: serde::Serializer,
1611    {
1612        use serde::ser::SerializeStruct;
1613        let mut len = 0;
1614        if self.mutation.is_some() {
1615            len += 1;
1616        }
1617        let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1618        if let Some(v) = self.mutation.as_ref() {
1619            match v {
1620                barrier_mutation::Mutation::Add(v) => {
1621                    struct_ser.serialize_field("add", v)?;
1622                }
1623                barrier_mutation::Mutation::Stop(v) => {
1624                    struct_ser.serialize_field("stop", v)?;
1625                }
1626                barrier_mutation::Mutation::Update(v) => {
1627                    struct_ser.serialize_field("update", v)?;
1628                }
1629                barrier_mutation::Mutation::Splits(v) => {
1630                    struct_ser.serialize_field("splits", v)?;
1631                }
1632                barrier_mutation::Mutation::Pause(v) => {
1633                    struct_ser.serialize_field("pause", v)?;
1634                }
1635                barrier_mutation::Mutation::Resume(v) => {
1636                    struct_ser.serialize_field("resume", v)?;
1637                }
1638                barrier_mutation::Mutation::Throttle(v) => {
1639                    struct_ser.serialize_field("throttle", v)?;
1640                }
1641                barrier_mutation::Mutation::DropSubscriptions(v) => {
1642                    struct_ser.serialize_field("dropSubscriptions", v)?;
1643                }
1644                barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1645                    struct_ser.serialize_field("connectorPropsChange", v)?;
1646                }
1647                barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1648                    struct_ser.serialize_field("startFragmentBackfill", v)?;
1649                }
1650                barrier_mutation::Mutation::Combined(v) => {
1651                    struct_ser.serialize_field("combined", v)?;
1652                }
1653            }
1654        }
1655        struct_ser.end()
1656    }
1657}
1658impl<'de> serde::Deserialize<'de> for BarrierMutation {
1659    #[allow(deprecated)]
1660    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1661    where
1662        D: serde::Deserializer<'de>,
1663    {
1664        const FIELDS: &[&str] = &[
1665            "add",
1666            "stop",
1667            "update",
1668            "splits",
1669            "pause",
1670            "resume",
1671            "throttle",
1672            "drop_subscriptions",
1673            "dropSubscriptions",
1674            "connector_props_change",
1675            "connectorPropsChange",
1676            "start_fragment_backfill",
1677            "startFragmentBackfill",
1678            "combined",
1679        ];
1680
1681        #[allow(clippy::enum_variant_names)]
1682        enum GeneratedField {
1683            Add,
1684            Stop,
1685            Update,
1686            Splits,
1687            Pause,
1688            Resume,
1689            Throttle,
1690            DropSubscriptions,
1691            ConnectorPropsChange,
1692            StartFragmentBackfill,
1693            Combined,
1694        }
1695        impl<'de> serde::Deserialize<'de> for GeneratedField {
1696            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1697            where
1698                D: serde::Deserializer<'de>,
1699            {
1700                struct GeneratedVisitor;
1701
1702                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1703                    type Value = GeneratedField;
1704
1705                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1706                        write!(formatter, "expected one of: {:?}", &FIELDS)
1707                    }
1708
1709                    #[allow(unused_variables)]
1710                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1711                    where
1712                        E: serde::de::Error,
1713                    {
1714                        match value {
1715                            "add" => Ok(GeneratedField::Add),
1716                            "stop" => Ok(GeneratedField::Stop),
1717                            "update" => Ok(GeneratedField::Update),
1718                            "splits" => Ok(GeneratedField::Splits),
1719                            "pause" => Ok(GeneratedField::Pause),
1720                            "resume" => Ok(GeneratedField::Resume),
1721                            "throttle" => Ok(GeneratedField::Throttle),
1722                            "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1723                            "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1724                            "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1725                            "combined" => Ok(GeneratedField::Combined),
1726                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1727                        }
1728                    }
1729                }
1730                deserializer.deserialize_identifier(GeneratedVisitor)
1731            }
1732        }
1733        struct GeneratedVisitor;
1734        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1735            type Value = BarrierMutation;
1736
1737            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1738                formatter.write_str("struct stream_plan.BarrierMutation")
1739            }
1740
1741            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1742                where
1743                    V: serde::de::MapAccess<'de>,
1744            {
1745                let mut mutation__ = None;
1746                while let Some(k) = map_.next_key()? {
1747                    match k {
1748                        GeneratedField::Add => {
1749                            if mutation__.is_some() {
1750                                return Err(serde::de::Error::duplicate_field("add"));
1751                            }
1752                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1753;
1754                        }
1755                        GeneratedField::Stop => {
1756                            if mutation__.is_some() {
1757                                return Err(serde::de::Error::duplicate_field("stop"));
1758                            }
1759                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1760;
1761                        }
1762                        GeneratedField::Update => {
1763                            if mutation__.is_some() {
1764                                return Err(serde::de::Error::duplicate_field("update"));
1765                            }
1766                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
1767;
1768                        }
1769                        GeneratedField::Splits => {
1770                            if mutation__.is_some() {
1771                                return Err(serde::de::Error::duplicate_field("splits"));
1772                            }
1773                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
1774;
1775                        }
1776                        GeneratedField::Pause => {
1777                            if mutation__.is_some() {
1778                                return Err(serde::de::Error::duplicate_field("pause"));
1779                            }
1780                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
1781;
1782                        }
1783                        GeneratedField::Resume => {
1784                            if mutation__.is_some() {
1785                                return Err(serde::de::Error::duplicate_field("resume"));
1786                            }
1787                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
1788;
1789                        }
1790                        GeneratedField::Throttle => {
1791                            if mutation__.is_some() {
1792                                return Err(serde::de::Error::duplicate_field("throttle"));
1793                            }
1794                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
1795;
1796                        }
1797                        GeneratedField::DropSubscriptions => {
1798                            if mutation__.is_some() {
1799                                return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
1800                            }
1801                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
1802;
1803                        }
1804                        GeneratedField::ConnectorPropsChange => {
1805                            if mutation__.is_some() {
1806                                return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
1807                            }
1808                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
1809;
1810                        }
1811                        GeneratedField::StartFragmentBackfill => {
1812                            if mutation__.is_some() {
1813                                return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
1814                            }
1815                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
1816;
1817                        }
1818                        GeneratedField::Combined => {
1819                            if mutation__.is_some() {
1820                                return Err(serde::de::Error::duplicate_field("combined"));
1821                            }
1822                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Combined)
1823;
1824                        }
1825                    }
1826                }
1827                Ok(BarrierMutation {
1828                    mutation: mutation__,
1829                })
1830            }
1831        }
1832        deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
1833    }
1834}
1835impl serde::Serialize for BarrierRecvNode {
1836    #[allow(deprecated)]
1837    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1838    where
1839        S: serde::Serializer,
1840    {
1841        use serde::ser::SerializeStruct;
1842        let len = 0;
1843        let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
1844        struct_ser.end()
1845    }
1846}
1847impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
1848    #[allow(deprecated)]
1849    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1850    where
1851        D: serde::Deserializer<'de>,
1852    {
1853        const FIELDS: &[&str] = &[
1854        ];
1855
1856        #[allow(clippy::enum_variant_names)]
1857        enum GeneratedField {
1858        }
1859        impl<'de> serde::Deserialize<'de> for GeneratedField {
1860            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1861            where
1862                D: serde::Deserializer<'de>,
1863            {
1864                struct GeneratedVisitor;
1865
1866                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1867                    type Value = GeneratedField;
1868
1869                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1870                        write!(formatter, "expected one of: {:?}", &FIELDS)
1871                    }
1872
1873                    #[allow(unused_variables)]
1874                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1875                    where
1876                        E: serde::de::Error,
1877                    {
1878                            Err(serde::de::Error::unknown_field(value, FIELDS))
1879                    }
1880                }
1881                deserializer.deserialize_identifier(GeneratedVisitor)
1882            }
1883        }
1884        struct GeneratedVisitor;
1885        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1886            type Value = BarrierRecvNode;
1887
1888            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1889                formatter.write_str("struct stream_plan.BarrierRecvNode")
1890            }
1891
1892            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
1893                where
1894                    V: serde::de::MapAccess<'de>,
1895            {
1896                while map_.next_key::<GeneratedField>()?.is_some() {
1897                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
1898                }
1899                Ok(BarrierRecvNode {
1900                })
1901            }
1902        }
1903        deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
1904    }
1905}
1906impl serde::Serialize for BatchPlanNode {
1907    #[allow(deprecated)]
1908    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1909    where
1910        S: serde::Serializer,
1911    {
1912        use serde::ser::SerializeStruct;
1913        let mut len = 0;
1914        if self.table_desc.is_some() {
1915            len += 1;
1916        }
1917        if !self.column_ids.is_empty() {
1918            len += 1;
1919        }
1920        let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
1921        if let Some(v) = self.table_desc.as_ref() {
1922            struct_ser.serialize_field("tableDesc", v)?;
1923        }
1924        if !self.column_ids.is_empty() {
1925            struct_ser.serialize_field("columnIds", &self.column_ids)?;
1926        }
1927        struct_ser.end()
1928    }
1929}
1930impl<'de> serde::Deserialize<'de> for BatchPlanNode {
1931    #[allow(deprecated)]
1932    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1933    where
1934        D: serde::Deserializer<'de>,
1935    {
1936        const FIELDS: &[&str] = &[
1937            "table_desc",
1938            "tableDesc",
1939            "column_ids",
1940            "columnIds",
1941        ];
1942
1943        #[allow(clippy::enum_variant_names)]
1944        enum GeneratedField {
1945            TableDesc,
1946            ColumnIds,
1947        }
1948        impl<'de> serde::Deserialize<'de> for GeneratedField {
1949            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1950            where
1951                D: serde::Deserializer<'de>,
1952            {
1953                struct GeneratedVisitor;
1954
1955                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1956                    type Value = GeneratedField;
1957
1958                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1959                        write!(formatter, "expected one of: {:?}", &FIELDS)
1960                    }
1961
1962                    #[allow(unused_variables)]
1963                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1964                    where
1965                        E: serde::de::Error,
1966                    {
1967                        match value {
1968                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
1969                            "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
1970                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1971                        }
1972                    }
1973                }
1974                deserializer.deserialize_identifier(GeneratedVisitor)
1975            }
1976        }
1977        struct GeneratedVisitor;
1978        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1979            type Value = BatchPlanNode;
1980
1981            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1982                formatter.write_str("struct stream_plan.BatchPlanNode")
1983            }
1984
1985            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
1986                where
1987                    V: serde::de::MapAccess<'de>,
1988            {
1989                let mut table_desc__ = None;
1990                let mut column_ids__ = None;
1991                while let Some(k) = map_.next_key()? {
1992                    match k {
1993                        GeneratedField::TableDesc => {
1994                            if table_desc__.is_some() {
1995                                return Err(serde::de::Error::duplicate_field("tableDesc"));
1996                            }
1997                            table_desc__ = map_.next_value()?;
1998                        }
1999                        GeneratedField::ColumnIds => {
2000                            if column_ids__.is_some() {
2001                                return Err(serde::de::Error::duplicate_field("columnIds"));
2002                            }
2003                            column_ids__ = 
2004                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2005                                    .into_iter().map(|x| x.0).collect())
2006                            ;
2007                        }
2008                    }
2009                }
2010                Ok(BatchPlanNode {
2011                    table_desc: table_desc__,
2012                    column_ids: column_ids__.unwrap_or_default(),
2013                })
2014            }
2015        }
2016        deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2017    }
2018}
2019impl serde::Serialize for CdcFilterNode {
2020    #[allow(deprecated)]
2021    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2022    where
2023        S: serde::Serializer,
2024    {
2025        use serde::ser::SerializeStruct;
2026        let mut len = 0;
2027        if self.search_condition.is_some() {
2028            len += 1;
2029        }
2030        if self.upstream_source_id != 0 {
2031            len += 1;
2032        }
2033        let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2034        if let Some(v) = self.search_condition.as_ref() {
2035            struct_ser.serialize_field("searchCondition", v)?;
2036        }
2037        if self.upstream_source_id != 0 {
2038            struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2039        }
2040        struct_ser.end()
2041    }
2042}
2043impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2044    #[allow(deprecated)]
2045    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2046    where
2047        D: serde::Deserializer<'de>,
2048    {
2049        const FIELDS: &[&str] = &[
2050            "search_condition",
2051            "searchCondition",
2052            "upstream_source_id",
2053            "upstreamSourceId",
2054        ];
2055
2056        #[allow(clippy::enum_variant_names)]
2057        enum GeneratedField {
2058            SearchCondition,
2059            UpstreamSourceId,
2060        }
2061        impl<'de> serde::Deserialize<'de> for GeneratedField {
2062            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2063            where
2064                D: serde::Deserializer<'de>,
2065            {
2066                struct GeneratedVisitor;
2067
2068                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2069                    type Value = GeneratedField;
2070
2071                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2072                        write!(formatter, "expected one of: {:?}", &FIELDS)
2073                    }
2074
2075                    #[allow(unused_variables)]
2076                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2077                    where
2078                        E: serde::de::Error,
2079                    {
2080                        match value {
2081                            "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2082                            "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2083                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2084                        }
2085                    }
2086                }
2087                deserializer.deserialize_identifier(GeneratedVisitor)
2088            }
2089        }
2090        struct GeneratedVisitor;
2091        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2092            type Value = CdcFilterNode;
2093
2094            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2095                formatter.write_str("struct stream_plan.CdcFilterNode")
2096            }
2097
2098            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2099                where
2100                    V: serde::de::MapAccess<'de>,
2101            {
2102                let mut search_condition__ = None;
2103                let mut upstream_source_id__ = None;
2104                while let Some(k) = map_.next_key()? {
2105                    match k {
2106                        GeneratedField::SearchCondition => {
2107                            if search_condition__.is_some() {
2108                                return Err(serde::de::Error::duplicate_field("searchCondition"));
2109                            }
2110                            search_condition__ = map_.next_value()?;
2111                        }
2112                        GeneratedField::UpstreamSourceId => {
2113                            if upstream_source_id__.is_some() {
2114                                return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2115                            }
2116                            upstream_source_id__ = 
2117                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2118                            ;
2119                        }
2120                    }
2121                }
2122                Ok(CdcFilterNode {
2123                    search_condition: search_condition__,
2124                    upstream_source_id: upstream_source_id__.unwrap_or_default(),
2125                })
2126            }
2127        }
2128        deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2129    }
2130}
2131impl serde::Serialize for ChangeLogNode {
2132    #[allow(deprecated)]
2133    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2134    where
2135        S: serde::Serializer,
2136    {
2137        use serde::ser::SerializeStruct;
2138        let mut len = 0;
2139        if self.need_op {
2140            len += 1;
2141        }
2142        let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2143        if self.need_op {
2144            struct_ser.serialize_field("needOp", &self.need_op)?;
2145        }
2146        struct_ser.end()
2147    }
2148}
2149impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2150    #[allow(deprecated)]
2151    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2152    where
2153        D: serde::Deserializer<'de>,
2154    {
2155        const FIELDS: &[&str] = &[
2156            "need_op",
2157            "needOp",
2158        ];
2159
2160        #[allow(clippy::enum_variant_names)]
2161        enum GeneratedField {
2162            NeedOp,
2163        }
2164        impl<'de> serde::Deserialize<'de> for GeneratedField {
2165            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2166            where
2167                D: serde::Deserializer<'de>,
2168            {
2169                struct GeneratedVisitor;
2170
2171                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2172                    type Value = GeneratedField;
2173
2174                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2175                        write!(formatter, "expected one of: {:?}", &FIELDS)
2176                    }
2177
2178                    #[allow(unused_variables)]
2179                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2180                    where
2181                        E: serde::de::Error,
2182                    {
2183                        match value {
2184                            "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2185                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2186                        }
2187                    }
2188                }
2189                deserializer.deserialize_identifier(GeneratedVisitor)
2190            }
2191        }
2192        struct GeneratedVisitor;
2193        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2194            type Value = ChangeLogNode;
2195
2196            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2197                formatter.write_str("struct stream_plan.ChangeLogNode")
2198            }
2199
2200            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2201                where
2202                    V: serde::de::MapAccess<'de>,
2203            {
2204                let mut need_op__ = None;
2205                while let Some(k) = map_.next_key()? {
2206                    match k {
2207                        GeneratedField::NeedOp => {
2208                            if need_op__.is_some() {
2209                                return Err(serde::de::Error::duplicate_field("needOp"));
2210                            }
2211                            need_op__ = Some(map_.next_value()?);
2212                        }
2213                    }
2214                }
2215                Ok(ChangeLogNode {
2216                    need_op: need_op__.unwrap_or_default(),
2217                })
2218            }
2219        }
2220        deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2221    }
2222}
2223impl serde::Serialize for CombinedMutation {
2224    #[allow(deprecated)]
2225    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2226    where
2227        S: serde::Serializer,
2228    {
2229        use serde::ser::SerializeStruct;
2230        let mut len = 0;
2231        if !self.mutations.is_empty() {
2232            len += 1;
2233        }
2234        let mut struct_ser = serializer.serialize_struct("stream_plan.CombinedMutation", len)?;
2235        if !self.mutations.is_empty() {
2236            struct_ser.serialize_field("mutations", &self.mutations)?;
2237        }
2238        struct_ser.end()
2239    }
2240}
2241impl<'de> serde::Deserialize<'de> for CombinedMutation {
2242    #[allow(deprecated)]
2243    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2244    where
2245        D: serde::Deserializer<'de>,
2246    {
2247        const FIELDS: &[&str] = &[
2248            "mutations",
2249        ];
2250
2251        #[allow(clippy::enum_variant_names)]
2252        enum GeneratedField {
2253            Mutations,
2254        }
2255        impl<'de> serde::Deserialize<'de> for GeneratedField {
2256            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2257            where
2258                D: serde::Deserializer<'de>,
2259            {
2260                struct GeneratedVisitor;
2261
2262                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2263                    type Value = GeneratedField;
2264
2265                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2266                        write!(formatter, "expected one of: {:?}", &FIELDS)
2267                    }
2268
2269                    #[allow(unused_variables)]
2270                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2271                    where
2272                        E: serde::de::Error,
2273                    {
2274                        match value {
2275                            "mutations" => Ok(GeneratedField::Mutations),
2276                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2277                        }
2278                    }
2279                }
2280                deserializer.deserialize_identifier(GeneratedVisitor)
2281            }
2282        }
2283        struct GeneratedVisitor;
2284        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2285            type Value = CombinedMutation;
2286
2287            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2288                formatter.write_str("struct stream_plan.CombinedMutation")
2289            }
2290
2291            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CombinedMutation, V::Error>
2292                where
2293                    V: serde::de::MapAccess<'de>,
2294            {
2295                let mut mutations__ = None;
2296                while let Some(k) = map_.next_key()? {
2297                    match k {
2298                        GeneratedField::Mutations => {
2299                            if mutations__.is_some() {
2300                                return Err(serde::de::Error::duplicate_field("mutations"));
2301                            }
2302                            mutations__ = Some(map_.next_value()?);
2303                        }
2304                    }
2305                }
2306                Ok(CombinedMutation {
2307                    mutations: mutations__.unwrap_or_default(),
2308                })
2309            }
2310        }
2311        deserializer.deserialize_struct("stream_plan.CombinedMutation", FIELDS, GeneratedVisitor)
2312    }
2313}
2314impl serde::Serialize for ConnectorPropsChangeMutation {
2315    #[allow(deprecated)]
2316    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2317    where
2318        S: serde::Serializer,
2319    {
2320        use serde::ser::SerializeStruct;
2321        let mut len = 0;
2322        if !self.connector_props_infos.is_empty() {
2323            len += 1;
2324        }
2325        let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2326        if !self.connector_props_infos.is_empty() {
2327            struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2328        }
2329        struct_ser.end()
2330    }
2331}
2332impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2333    #[allow(deprecated)]
2334    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2335    where
2336        D: serde::Deserializer<'de>,
2337    {
2338        const FIELDS: &[&str] = &[
2339            "connector_props_infos",
2340            "connectorPropsInfos",
2341        ];
2342
2343        #[allow(clippy::enum_variant_names)]
2344        enum GeneratedField {
2345            ConnectorPropsInfos,
2346        }
2347        impl<'de> serde::Deserialize<'de> for GeneratedField {
2348            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2349            where
2350                D: serde::Deserializer<'de>,
2351            {
2352                struct GeneratedVisitor;
2353
2354                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2355                    type Value = GeneratedField;
2356
2357                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2358                        write!(formatter, "expected one of: {:?}", &FIELDS)
2359                    }
2360
2361                    #[allow(unused_variables)]
2362                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2363                    where
2364                        E: serde::de::Error,
2365                    {
2366                        match value {
2367                            "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2368                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2369                        }
2370                    }
2371                }
2372                deserializer.deserialize_identifier(GeneratedVisitor)
2373            }
2374        }
2375        struct GeneratedVisitor;
2376        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2377            type Value = ConnectorPropsChangeMutation;
2378
2379            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2380                formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2381            }
2382
2383            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2384                where
2385                    V: serde::de::MapAccess<'de>,
2386            {
2387                let mut connector_props_infos__ = None;
2388                while let Some(k) = map_.next_key()? {
2389                    match k {
2390                        GeneratedField::ConnectorPropsInfos => {
2391                            if connector_props_infos__.is_some() {
2392                                return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2393                            }
2394                            connector_props_infos__ = Some(
2395                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2396                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
2397                            );
2398                        }
2399                    }
2400                }
2401                Ok(ConnectorPropsChangeMutation {
2402                    connector_props_infos: connector_props_infos__.unwrap_or_default(),
2403                })
2404            }
2405        }
2406        deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2407    }
2408}
2409impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2410    #[allow(deprecated)]
2411    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2412    where
2413        S: serde::Serializer,
2414    {
2415        use serde::ser::SerializeStruct;
2416        let mut len = 0;
2417        if !self.connector_props_info.is_empty() {
2418            len += 1;
2419        }
2420        let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2421        if !self.connector_props_info.is_empty() {
2422            struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2423        }
2424        struct_ser.end()
2425    }
2426}
2427impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2428    #[allow(deprecated)]
2429    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2430    where
2431        D: serde::Deserializer<'de>,
2432    {
2433        const FIELDS: &[&str] = &[
2434            "connector_props_info",
2435            "connectorPropsInfo",
2436        ];
2437
2438        #[allow(clippy::enum_variant_names)]
2439        enum GeneratedField {
2440            ConnectorPropsInfo,
2441        }
2442        impl<'de> serde::Deserialize<'de> for GeneratedField {
2443            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2444            where
2445                D: serde::Deserializer<'de>,
2446            {
2447                struct GeneratedVisitor;
2448
2449                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2450                    type Value = GeneratedField;
2451
2452                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2453                        write!(formatter, "expected one of: {:?}", &FIELDS)
2454                    }
2455
2456                    #[allow(unused_variables)]
2457                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2458                    where
2459                        E: serde::de::Error,
2460                    {
2461                        match value {
2462                            "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2463                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2464                        }
2465                    }
2466                }
2467                deserializer.deserialize_identifier(GeneratedVisitor)
2468            }
2469        }
2470        struct GeneratedVisitor;
2471        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2472            type Value = connector_props_change_mutation::ConnectorPropsInfo;
2473
2474            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2475                formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2476            }
2477
2478            fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2479                where
2480                    V: serde::de::MapAccess<'de>,
2481            {
2482                let mut connector_props_info__ = None;
2483                while let Some(k) = map_.next_key()? {
2484                    match k {
2485                        GeneratedField::ConnectorPropsInfo => {
2486                            if connector_props_info__.is_some() {
2487                                return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2488                            }
2489                            connector_props_info__ = Some(
2490                                map_.next_value::<std::collections::HashMap<_, _>>()?
2491                            );
2492                        }
2493                    }
2494                }
2495                Ok(connector_props_change_mutation::ConnectorPropsInfo {
2496                    connector_props_info: connector_props_info__.unwrap_or_default(),
2497                })
2498            }
2499        }
2500        deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2501    }
2502}
2503impl serde::Serialize for DedupNode {
2504    #[allow(deprecated)]
2505    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2506    where
2507        S: serde::Serializer,
2508    {
2509        use serde::ser::SerializeStruct;
2510        let mut len = 0;
2511        if self.state_table.is_some() {
2512            len += 1;
2513        }
2514        if !self.dedup_column_indices.is_empty() {
2515            len += 1;
2516        }
2517        let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
2518        if let Some(v) = self.state_table.as_ref() {
2519            struct_ser.serialize_field("stateTable", v)?;
2520        }
2521        if !self.dedup_column_indices.is_empty() {
2522            struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
2523        }
2524        struct_ser.end()
2525    }
2526}
2527impl<'de> serde::Deserialize<'de> for DedupNode {
2528    #[allow(deprecated)]
2529    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2530    where
2531        D: serde::Deserializer<'de>,
2532    {
2533        const FIELDS: &[&str] = &[
2534            "state_table",
2535            "stateTable",
2536            "dedup_column_indices",
2537            "dedupColumnIndices",
2538        ];
2539
2540        #[allow(clippy::enum_variant_names)]
2541        enum GeneratedField {
2542            StateTable,
2543            DedupColumnIndices,
2544        }
2545        impl<'de> serde::Deserialize<'de> for GeneratedField {
2546            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2547            where
2548                D: serde::Deserializer<'de>,
2549            {
2550                struct GeneratedVisitor;
2551
2552                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2553                    type Value = GeneratedField;
2554
2555                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2556                        write!(formatter, "expected one of: {:?}", &FIELDS)
2557                    }
2558
2559                    #[allow(unused_variables)]
2560                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2561                    where
2562                        E: serde::de::Error,
2563                    {
2564                        match value {
2565                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
2566                            "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
2567                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2568                        }
2569                    }
2570                }
2571                deserializer.deserialize_identifier(GeneratedVisitor)
2572            }
2573        }
2574        struct GeneratedVisitor;
2575        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2576            type Value = DedupNode;
2577
2578            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2579                formatter.write_str("struct stream_plan.DedupNode")
2580            }
2581
2582            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
2583                where
2584                    V: serde::de::MapAccess<'de>,
2585            {
2586                let mut state_table__ = None;
2587                let mut dedup_column_indices__ = None;
2588                while let Some(k) = map_.next_key()? {
2589                    match k {
2590                        GeneratedField::StateTable => {
2591                            if state_table__.is_some() {
2592                                return Err(serde::de::Error::duplicate_field("stateTable"));
2593                            }
2594                            state_table__ = map_.next_value()?;
2595                        }
2596                        GeneratedField::DedupColumnIndices => {
2597                            if dedup_column_indices__.is_some() {
2598                                return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
2599                            }
2600                            dedup_column_indices__ = 
2601                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2602                                    .into_iter().map(|x| x.0).collect())
2603                            ;
2604                        }
2605                    }
2606                }
2607                Ok(DedupNode {
2608                    state_table: state_table__,
2609                    dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
2610                })
2611            }
2612        }
2613        deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
2614    }
2615}
2616impl serde::Serialize for DeltaExpression {
2617    #[allow(deprecated)]
2618    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2619    where
2620        S: serde::Serializer,
2621    {
2622        use serde::ser::SerializeStruct;
2623        let mut len = 0;
2624        if self.delta_type != 0 {
2625            len += 1;
2626        }
2627        if self.delta.is_some() {
2628            len += 1;
2629        }
2630        let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
2631        if self.delta_type != 0 {
2632            let v = super::expr::expr_node::Type::try_from(self.delta_type)
2633                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
2634            struct_ser.serialize_field("deltaType", &v)?;
2635        }
2636        if let Some(v) = self.delta.as_ref() {
2637            struct_ser.serialize_field("delta", v)?;
2638        }
2639        struct_ser.end()
2640    }
2641}
2642impl<'de> serde::Deserialize<'de> for DeltaExpression {
2643    #[allow(deprecated)]
2644    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2645    where
2646        D: serde::Deserializer<'de>,
2647    {
2648        const FIELDS: &[&str] = &[
2649            "delta_type",
2650            "deltaType",
2651            "delta",
2652        ];
2653
2654        #[allow(clippy::enum_variant_names)]
2655        enum GeneratedField {
2656            DeltaType,
2657            Delta,
2658        }
2659        impl<'de> serde::Deserialize<'de> for GeneratedField {
2660            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2661            where
2662                D: serde::Deserializer<'de>,
2663            {
2664                struct GeneratedVisitor;
2665
2666                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2667                    type Value = GeneratedField;
2668
2669                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2670                        write!(formatter, "expected one of: {:?}", &FIELDS)
2671                    }
2672
2673                    #[allow(unused_variables)]
2674                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2675                    where
2676                        E: serde::de::Error,
2677                    {
2678                        match value {
2679                            "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
2680                            "delta" => Ok(GeneratedField::Delta),
2681                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2682                        }
2683                    }
2684                }
2685                deserializer.deserialize_identifier(GeneratedVisitor)
2686            }
2687        }
2688        struct GeneratedVisitor;
2689        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2690            type Value = DeltaExpression;
2691
2692            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2693                formatter.write_str("struct stream_plan.DeltaExpression")
2694            }
2695
2696            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
2697                where
2698                    V: serde::de::MapAccess<'de>,
2699            {
2700                let mut delta_type__ = None;
2701                let mut delta__ = None;
2702                while let Some(k) = map_.next_key()? {
2703                    match k {
2704                        GeneratedField::DeltaType => {
2705                            if delta_type__.is_some() {
2706                                return Err(serde::de::Error::duplicate_field("deltaType"));
2707                            }
2708                            delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
2709                        }
2710                        GeneratedField::Delta => {
2711                            if delta__.is_some() {
2712                                return Err(serde::de::Error::duplicate_field("delta"));
2713                            }
2714                            delta__ = map_.next_value()?;
2715                        }
2716                    }
2717                }
2718                Ok(DeltaExpression {
2719                    delta_type: delta_type__.unwrap_or_default(),
2720                    delta: delta__,
2721                })
2722            }
2723        }
2724        deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
2725    }
2726}
2727impl serde::Serialize for DeltaIndexJoinNode {
2728    #[allow(deprecated)]
2729    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2730    where
2731        S: serde::Serializer,
2732    {
2733        use serde::ser::SerializeStruct;
2734        let mut len = 0;
2735        if self.join_type != 0 {
2736            len += 1;
2737        }
2738        if !self.left_key.is_empty() {
2739            len += 1;
2740        }
2741        if !self.right_key.is_empty() {
2742            len += 1;
2743        }
2744        if self.condition.is_some() {
2745            len += 1;
2746        }
2747        if self.left_table_id != 0 {
2748            len += 1;
2749        }
2750        if self.right_table_id != 0 {
2751            len += 1;
2752        }
2753        if self.left_info.is_some() {
2754            len += 1;
2755        }
2756        if self.right_info.is_some() {
2757            len += 1;
2758        }
2759        if !self.output_indices.is_empty() {
2760            len += 1;
2761        }
2762        let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
2763        if self.join_type != 0 {
2764            let v = super::plan_common::JoinType::try_from(self.join_type)
2765                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
2766            struct_ser.serialize_field("joinType", &v)?;
2767        }
2768        if !self.left_key.is_empty() {
2769            struct_ser.serialize_field("leftKey", &self.left_key)?;
2770        }
2771        if !self.right_key.is_empty() {
2772            struct_ser.serialize_field("rightKey", &self.right_key)?;
2773        }
2774        if let Some(v) = self.condition.as_ref() {
2775            struct_ser.serialize_field("condition", v)?;
2776        }
2777        if self.left_table_id != 0 {
2778            struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
2779        }
2780        if self.right_table_id != 0 {
2781            struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
2782        }
2783        if let Some(v) = self.left_info.as_ref() {
2784            struct_ser.serialize_field("leftInfo", v)?;
2785        }
2786        if let Some(v) = self.right_info.as_ref() {
2787            struct_ser.serialize_field("rightInfo", v)?;
2788        }
2789        if !self.output_indices.is_empty() {
2790            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
2791        }
2792        struct_ser.end()
2793    }
2794}
2795impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
2796    #[allow(deprecated)]
2797    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2798    where
2799        D: serde::Deserializer<'de>,
2800    {
2801        const FIELDS: &[&str] = &[
2802            "join_type",
2803            "joinType",
2804            "left_key",
2805            "leftKey",
2806            "right_key",
2807            "rightKey",
2808            "condition",
2809            "left_table_id",
2810            "leftTableId",
2811            "right_table_id",
2812            "rightTableId",
2813            "left_info",
2814            "leftInfo",
2815            "right_info",
2816            "rightInfo",
2817            "output_indices",
2818            "outputIndices",
2819        ];
2820
2821        #[allow(clippy::enum_variant_names)]
2822        enum GeneratedField {
2823            JoinType,
2824            LeftKey,
2825            RightKey,
2826            Condition,
2827            LeftTableId,
2828            RightTableId,
2829            LeftInfo,
2830            RightInfo,
2831            OutputIndices,
2832        }
2833        impl<'de> serde::Deserialize<'de> for GeneratedField {
2834            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2835            where
2836                D: serde::Deserializer<'de>,
2837            {
2838                struct GeneratedVisitor;
2839
2840                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2841                    type Value = GeneratedField;
2842
2843                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2844                        write!(formatter, "expected one of: {:?}", &FIELDS)
2845                    }
2846
2847                    #[allow(unused_variables)]
2848                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2849                    where
2850                        E: serde::de::Error,
2851                    {
2852                        match value {
2853                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
2854                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
2855                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
2856                            "condition" => Ok(GeneratedField::Condition),
2857                            "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
2858                            "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
2859                            "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
2860                            "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
2861                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
2862                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2863                        }
2864                    }
2865                }
2866                deserializer.deserialize_identifier(GeneratedVisitor)
2867            }
2868        }
2869        struct GeneratedVisitor;
2870        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2871            type Value = DeltaIndexJoinNode;
2872
2873            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2874                formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
2875            }
2876
2877            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
2878                where
2879                    V: serde::de::MapAccess<'de>,
2880            {
2881                let mut join_type__ = None;
2882                let mut left_key__ = None;
2883                let mut right_key__ = None;
2884                let mut condition__ = None;
2885                let mut left_table_id__ = None;
2886                let mut right_table_id__ = None;
2887                let mut left_info__ = None;
2888                let mut right_info__ = None;
2889                let mut output_indices__ = None;
2890                while let Some(k) = map_.next_key()? {
2891                    match k {
2892                        GeneratedField::JoinType => {
2893                            if join_type__.is_some() {
2894                                return Err(serde::de::Error::duplicate_field("joinType"));
2895                            }
2896                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
2897                        }
2898                        GeneratedField::LeftKey => {
2899                            if left_key__.is_some() {
2900                                return Err(serde::de::Error::duplicate_field("leftKey"));
2901                            }
2902                            left_key__ = 
2903                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2904                                    .into_iter().map(|x| x.0).collect())
2905                            ;
2906                        }
2907                        GeneratedField::RightKey => {
2908                            if right_key__.is_some() {
2909                                return Err(serde::de::Error::duplicate_field("rightKey"));
2910                            }
2911                            right_key__ = 
2912                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2913                                    .into_iter().map(|x| x.0).collect())
2914                            ;
2915                        }
2916                        GeneratedField::Condition => {
2917                            if condition__.is_some() {
2918                                return Err(serde::de::Error::duplicate_field("condition"));
2919                            }
2920                            condition__ = map_.next_value()?;
2921                        }
2922                        GeneratedField::LeftTableId => {
2923                            if left_table_id__.is_some() {
2924                                return Err(serde::de::Error::duplicate_field("leftTableId"));
2925                            }
2926                            left_table_id__ = 
2927                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2928                            ;
2929                        }
2930                        GeneratedField::RightTableId => {
2931                            if right_table_id__.is_some() {
2932                                return Err(serde::de::Error::duplicate_field("rightTableId"));
2933                            }
2934                            right_table_id__ = 
2935                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2936                            ;
2937                        }
2938                        GeneratedField::LeftInfo => {
2939                            if left_info__.is_some() {
2940                                return Err(serde::de::Error::duplicate_field("leftInfo"));
2941                            }
2942                            left_info__ = map_.next_value()?;
2943                        }
2944                        GeneratedField::RightInfo => {
2945                            if right_info__.is_some() {
2946                                return Err(serde::de::Error::duplicate_field("rightInfo"));
2947                            }
2948                            right_info__ = map_.next_value()?;
2949                        }
2950                        GeneratedField::OutputIndices => {
2951                            if output_indices__.is_some() {
2952                                return Err(serde::de::Error::duplicate_field("outputIndices"));
2953                            }
2954                            output_indices__ = 
2955                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2956                                    .into_iter().map(|x| x.0).collect())
2957                            ;
2958                        }
2959                    }
2960                }
2961                Ok(DeltaIndexJoinNode {
2962                    join_type: join_type__.unwrap_or_default(),
2963                    left_key: left_key__.unwrap_or_default(),
2964                    right_key: right_key__.unwrap_or_default(),
2965                    condition: condition__,
2966                    left_table_id: left_table_id__.unwrap_or_default(),
2967                    right_table_id: right_table_id__.unwrap_or_default(),
2968                    left_info: left_info__,
2969                    right_info: right_info__,
2970                    output_indices: output_indices__.unwrap_or_default(),
2971                })
2972            }
2973        }
2974        deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
2975    }
2976}
2977impl serde::Serialize for DispatchOutputMapping {
2978    #[allow(deprecated)]
2979    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2980    where
2981        S: serde::Serializer,
2982    {
2983        use serde::ser::SerializeStruct;
2984        let mut len = 0;
2985        if !self.indices.is_empty() {
2986            len += 1;
2987        }
2988        if !self.types.is_empty() {
2989            len += 1;
2990        }
2991        let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
2992        if !self.indices.is_empty() {
2993            struct_ser.serialize_field("indices", &self.indices)?;
2994        }
2995        if !self.types.is_empty() {
2996            struct_ser.serialize_field("types", &self.types)?;
2997        }
2998        struct_ser.end()
2999    }
3000}
3001impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3002    #[allow(deprecated)]
3003    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3004    where
3005        D: serde::Deserializer<'de>,
3006    {
3007        const FIELDS: &[&str] = &[
3008            "indices",
3009            "types",
3010        ];
3011
3012        #[allow(clippy::enum_variant_names)]
3013        enum GeneratedField {
3014            Indices,
3015            Types,
3016        }
3017        impl<'de> serde::Deserialize<'de> for GeneratedField {
3018            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3019            where
3020                D: serde::Deserializer<'de>,
3021            {
3022                struct GeneratedVisitor;
3023
3024                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3025                    type Value = GeneratedField;
3026
3027                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3028                        write!(formatter, "expected one of: {:?}", &FIELDS)
3029                    }
3030
3031                    #[allow(unused_variables)]
3032                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3033                    where
3034                        E: serde::de::Error,
3035                    {
3036                        match value {
3037                            "indices" => Ok(GeneratedField::Indices),
3038                            "types" => Ok(GeneratedField::Types),
3039                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3040                        }
3041                    }
3042                }
3043                deserializer.deserialize_identifier(GeneratedVisitor)
3044            }
3045        }
3046        struct GeneratedVisitor;
3047        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3048            type Value = DispatchOutputMapping;
3049
3050            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3051                formatter.write_str("struct stream_plan.DispatchOutputMapping")
3052            }
3053
3054            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3055                where
3056                    V: serde::de::MapAccess<'de>,
3057            {
3058                let mut indices__ = None;
3059                let mut types__ = None;
3060                while let Some(k) = map_.next_key()? {
3061                    match k {
3062                        GeneratedField::Indices => {
3063                            if indices__.is_some() {
3064                                return Err(serde::de::Error::duplicate_field("indices"));
3065                            }
3066                            indices__ = 
3067                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3068                                    .into_iter().map(|x| x.0).collect())
3069                            ;
3070                        }
3071                        GeneratedField::Types => {
3072                            if types__.is_some() {
3073                                return Err(serde::de::Error::duplicate_field("types"));
3074                            }
3075                            types__ = Some(map_.next_value()?);
3076                        }
3077                    }
3078                }
3079                Ok(DispatchOutputMapping {
3080                    indices: indices__.unwrap_or_default(),
3081                    types: types__.unwrap_or_default(),
3082                })
3083            }
3084        }
3085        deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3086    }
3087}
3088impl serde::Serialize for dispatch_output_mapping::TypePair {
3089    #[allow(deprecated)]
3090    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3091    where
3092        S: serde::Serializer,
3093    {
3094        use serde::ser::SerializeStruct;
3095        let mut len = 0;
3096        if self.upstream.is_some() {
3097            len += 1;
3098        }
3099        if self.downstream.is_some() {
3100            len += 1;
3101        }
3102        let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3103        if let Some(v) = self.upstream.as_ref() {
3104            struct_ser.serialize_field("upstream", v)?;
3105        }
3106        if let Some(v) = self.downstream.as_ref() {
3107            struct_ser.serialize_field("downstream", v)?;
3108        }
3109        struct_ser.end()
3110    }
3111}
3112impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3113    #[allow(deprecated)]
3114    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3115    where
3116        D: serde::Deserializer<'de>,
3117    {
3118        const FIELDS: &[&str] = &[
3119            "upstream",
3120            "downstream",
3121        ];
3122
3123        #[allow(clippy::enum_variant_names)]
3124        enum GeneratedField {
3125            Upstream,
3126            Downstream,
3127        }
3128        impl<'de> serde::Deserialize<'de> for GeneratedField {
3129            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3130            where
3131                D: serde::Deserializer<'de>,
3132            {
3133                struct GeneratedVisitor;
3134
3135                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3136                    type Value = GeneratedField;
3137
3138                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3139                        write!(formatter, "expected one of: {:?}", &FIELDS)
3140                    }
3141
3142                    #[allow(unused_variables)]
3143                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3144                    where
3145                        E: serde::de::Error,
3146                    {
3147                        match value {
3148                            "upstream" => Ok(GeneratedField::Upstream),
3149                            "downstream" => Ok(GeneratedField::Downstream),
3150                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3151                        }
3152                    }
3153                }
3154                deserializer.deserialize_identifier(GeneratedVisitor)
3155            }
3156        }
3157        struct GeneratedVisitor;
3158        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3159            type Value = dispatch_output_mapping::TypePair;
3160
3161            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3162                formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3163            }
3164
3165            fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3166                where
3167                    V: serde::de::MapAccess<'de>,
3168            {
3169                let mut upstream__ = None;
3170                let mut downstream__ = None;
3171                while let Some(k) = map_.next_key()? {
3172                    match k {
3173                        GeneratedField::Upstream => {
3174                            if upstream__.is_some() {
3175                                return Err(serde::de::Error::duplicate_field("upstream"));
3176                            }
3177                            upstream__ = map_.next_value()?;
3178                        }
3179                        GeneratedField::Downstream => {
3180                            if downstream__.is_some() {
3181                                return Err(serde::de::Error::duplicate_field("downstream"));
3182                            }
3183                            downstream__ = map_.next_value()?;
3184                        }
3185                    }
3186                }
3187                Ok(dispatch_output_mapping::TypePair {
3188                    upstream: upstream__,
3189                    downstream: downstream__,
3190                })
3191            }
3192        }
3193        deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3194    }
3195}
3196impl serde::Serialize for DispatchStrategy {
3197    #[allow(deprecated)]
3198    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3199    where
3200        S: serde::Serializer,
3201    {
3202        use serde::ser::SerializeStruct;
3203        let mut len = 0;
3204        if self.r#type != 0 {
3205            len += 1;
3206        }
3207        if !self.dist_key_indices.is_empty() {
3208            len += 1;
3209        }
3210        if self.output_mapping.is_some() {
3211            len += 1;
3212        }
3213        let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3214        if self.r#type != 0 {
3215            let v = DispatcherType::try_from(self.r#type)
3216                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3217            struct_ser.serialize_field("type", &v)?;
3218        }
3219        if !self.dist_key_indices.is_empty() {
3220            struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3221        }
3222        if let Some(v) = self.output_mapping.as_ref() {
3223            struct_ser.serialize_field("outputMapping", v)?;
3224        }
3225        struct_ser.end()
3226    }
3227}
3228impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3229    #[allow(deprecated)]
3230    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3231    where
3232        D: serde::Deserializer<'de>,
3233    {
3234        const FIELDS: &[&str] = &[
3235            "type",
3236            "dist_key_indices",
3237            "distKeyIndices",
3238            "output_mapping",
3239            "outputMapping",
3240        ];
3241
3242        #[allow(clippy::enum_variant_names)]
3243        enum GeneratedField {
3244            Type,
3245            DistKeyIndices,
3246            OutputMapping,
3247        }
3248        impl<'de> serde::Deserialize<'de> for GeneratedField {
3249            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3250            where
3251                D: serde::Deserializer<'de>,
3252            {
3253                struct GeneratedVisitor;
3254
3255                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3256                    type Value = GeneratedField;
3257
3258                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3259                        write!(formatter, "expected one of: {:?}", &FIELDS)
3260                    }
3261
3262                    #[allow(unused_variables)]
3263                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3264                    where
3265                        E: serde::de::Error,
3266                    {
3267                        match value {
3268                            "type" => Ok(GeneratedField::Type),
3269                            "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3270                            "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3271                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3272                        }
3273                    }
3274                }
3275                deserializer.deserialize_identifier(GeneratedVisitor)
3276            }
3277        }
3278        struct GeneratedVisitor;
3279        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3280            type Value = DispatchStrategy;
3281
3282            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3283                formatter.write_str("struct stream_plan.DispatchStrategy")
3284            }
3285
3286            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3287                where
3288                    V: serde::de::MapAccess<'de>,
3289            {
3290                let mut r#type__ = None;
3291                let mut dist_key_indices__ = None;
3292                let mut output_mapping__ = None;
3293                while let Some(k) = map_.next_key()? {
3294                    match k {
3295                        GeneratedField::Type => {
3296                            if r#type__.is_some() {
3297                                return Err(serde::de::Error::duplicate_field("type"));
3298                            }
3299                            r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3300                        }
3301                        GeneratedField::DistKeyIndices => {
3302                            if dist_key_indices__.is_some() {
3303                                return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3304                            }
3305                            dist_key_indices__ = 
3306                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3307                                    .into_iter().map(|x| x.0).collect())
3308                            ;
3309                        }
3310                        GeneratedField::OutputMapping => {
3311                            if output_mapping__.is_some() {
3312                                return Err(serde::de::Error::duplicate_field("outputMapping"));
3313                            }
3314                            output_mapping__ = map_.next_value()?;
3315                        }
3316                    }
3317                }
3318                Ok(DispatchStrategy {
3319                    r#type: r#type__.unwrap_or_default(),
3320                    dist_key_indices: dist_key_indices__.unwrap_or_default(),
3321                    output_mapping: output_mapping__,
3322                })
3323            }
3324        }
3325        deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3326    }
3327}
3328impl serde::Serialize for Dispatcher {
3329    #[allow(deprecated)]
3330    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3331    where
3332        S: serde::Serializer,
3333    {
3334        use serde::ser::SerializeStruct;
3335        let mut len = 0;
3336        if self.r#type != 0 {
3337            len += 1;
3338        }
3339        if !self.dist_key_indices.is_empty() {
3340            len += 1;
3341        }
3342        if self.output_mapping.is_some() {
3343            len += 1;
3344        }
3345        if self.hash_mapping.is_some() {
3346            len += 1;
3347        }
3348        if self.dispatcher_id != 0 {
3349            len += 1;
3350        }
3351        if !self.downstream_actor_id.is_empty() {
3352            len += 1;
3353        }
3354        let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3355        if self.r#type != 0 {
3356            let v = DispatcherType::try_from(self.r#type)
3357                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3358            struct_ser.serialize_field("type", &v)?;
3359        }
3360        if !self.dist_key_indices.is_empty() {
3361            struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3362        }
3363        if let Some(v) = self.output_mapping.as_ref() {
3364            struct_ser.serialize_field("outputMapping", v)?;
3365        }
3366        if let Some(v) = self.hash_mapping.as_ref() {
3367            struct_ser.serialize_field("hashMapping", v)?;
3368        }
3369        if self.dispatcher_id != 0 {
3370            #[allow(clippy::needless_borrow)]
3371            #[allow(clippy::needless_borrows_for_generic_args)]
3372            struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
3373        }
3374        if !self.downstream_actor_id.is_empty() {
3375            struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3376        }
3377        struct_ser.end()
3378    }
3379}
3380impl<'de> serde::Deserialize<'de> for Dispatcher {
3381    #[allow(deprecated)]
3382    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3383    where
3384        D: serde::Deserializer<'de>,
3385    {
3386        const FIELDS: &[&str] = &[
3387            "type",
3388            "dist_key_indices",
3389            "distKeyIndices",
3390            "output_mapping",
3391            "outputMapping",
3392            "hash_mapping",
3393            "hashMapping",
3394            "dispatcher_id",
3395            "dispatcherId",
3396            "downstream_actor_id",
3397            "downstreamActorId",
3398        ];
3399
3400        #[allow(clippy::enum_variant_names)]
3401        enum GeneratedField {
3402            Type,
3403            DistKeyIndices,
3404            OutputMapping,
3405            HashMapping,
3406            DispatcherId,
3407            DownstreamActorId,
3408        }
3409        impl<'de> serde::Deserialize<'de> for GeneratedField {
3410            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3411            where
3412                D: serde::Deserializer<'de>,
3413            {
3414                struct GeneratedVisitor;
3415
3416                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3417                    type Value = GeneratedField;
3418
3419                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3420                        write!(formatter, "expected one of: {:?}", &FIELDS)
3421                    }
3422
3423                    #[allow(unused_variables)]
3424                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3425                    where
3426                        E: serde::de::Error,
3427                    {
3428                        match value {
3429                            "type" => Ok(GeneratedField::Type),
3430                            "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3431                            "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3432                            "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3433                            "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3434                            "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3435                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3436                        }
3437                    }
3438                }
3439                deserializer.deserialize_identifier(GeneratedVisitor)
3440            }
3441        }
3442        struct GeneratedVisitor;
3443        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3444            type Value = Dispatcher;
3445
3446            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3447                formatter.write_str("struct stream_plan.Dispatcher")
3448            }
3449
3450            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3451                where
3452                    V: serde::de::MapAccess<'de>,
3453            {
3454                let mut r#type__ = None;
3455                let mut dist_key_indices__ = None;
3456                let mut output_mapping__ = None;
3457                let mut hash_mapping__ = None;
3458                let mut dispatcher_id__ = None;
3459                let mut downstream_actor_id__ = None;
3460                while let Some(k) = map_.next_key()? {
3461                    match k {
3462                        GeneratedField::Type => {
3463                            if r#type__.is_some() {
3464                                return Err(serde::de::Error::duplicate_field("type"));
3465                            }
3466                            r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3467                        }
3468                        GeneratedField::DistKeyIndices => {
3469                            if dist_key_indices__.is_some() {
3470                                return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3471                            }
3472                            dist_key_indices__ = 
3473                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3474                                    .into_iter().map(|x| x.0).collect())
3475                            ;
3476                        }
3477                        GeneratedField::OutputMapping => {
3478                            if output_mapping__.is_some() {
3479                                return Err(serde::de::Error::duplicate_field("outputMapping"));
3480                            }
3481                            output_mapping__ = map_.next_value()?;
3482                        }
3483                        GeneratedField::HashMapping => {
3484                            if hash_mapping__.is_some() {
3485                                return Err(serde::de::Error::duplicate_field("hashMapping"));
3486                            }
3487                            hash_mapping__ = map_.next_value()?;
3488                        }
3489                        GeneratedField::DispatcherId => {
3490                            if dispatcher_id__.is_some() {
3491                                return Err(serde::de::Error::duplicate_field("dispatcherId"));
3492                            }
3493                            dispatcher_id__ = 
3494                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3495                            ;
3496                        }
3497                        GeneratedField::DownstreamActorId => {
3498                            if downstream_actor_id__.is_some() {
3499                                return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3500                            }
3501                            downstream_actor_id__ = 
3502                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3503                                    .into_iter().map(|x| x.0).collect())
3504                            ;
3505                        }
3506                    }
3507                }
3508                Ok(Dispatcher {
3509                    r#type: r#type__.unwrap_or_default(),
3510                    dist_key_indices: dist_key_indices__.unwrap_or_default(),
3511                    output_mapping: output_mapping__,
3512                    hash_mapping: hash_mapping__,
3513                    dispatcher_id: dispatcher_id__.unwrap_or_default(),
3514                    downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3515                })
3516            }
3517        }
3518        deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3519    }
3520}
3521impl serde::Serialize for DispatcherType {
3522    #[allow(deprecated)]
3523    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3524    where
3525        S: serde::Serializer,
3526    {
3527        let variant = match self {
3528            Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3529            Self::Hash => "DISPATCHER_TYPE_HASH",
3530            Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3531            Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3532            Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3533        };
3534        serializer.serialize_str(variant)
3535    }
3536}
3537impl<'de> serde::Deserialize<'de> for DispatcherType {
3538    #[allow(deprecated)]
3539    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3540    where
3541        D: serde::Deserializer<'de>,
3542    {
3543        const FIELDS: &[&str] = &[
3544            "DISPATCHER_TYPE_UNSPECIFIED",
3545            "DISPATCHER_TYPE_HASH",
3546            "DISPATCHER_TYPE_BROADCAST",
3547            "DISPATCHER_TYPE_SIMPLE",
3548            "DISPATCHER_TYPE_NO_SHUFFLE",
3549        ];
3550
3551        struct GeneratedVisitor;
3552
3553        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3554            type Value = DispatcherType;
3555
3556            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3557                write!(formatter, "expected one of: {:?}", &FIELDS)
3558            }
3559
3560            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3561            where
3562                E: serde::de::Error,
3563            {
3564                i32::try_from(v)
3565                    .ok()
3566                    .and_then(|x| x.try_into().ok())
3567                    .ok_or_else(|| {
3568                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3569                    })
3570            }
3571
3572            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3573            where
3574                E: serde::de::Error,
3575            {
3576                i32::try_from(v)
3577                    .ok()
3578                    .and_then(|x| x.try_into().ok())
3579                    .ok_or_else(|| {
3580                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3581                    })
3582            }
3583
3584            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3585            where
3586                E: serde::de::Error,
3587            {
3588                match value {
3589                    "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3590                    "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3591                    "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3592                    "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3593                    "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3594                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3595                }
3596            }
3597        }
3598        deserializer.deserialize_any(GeneratedVisitor)
3599    }
3600}
3601impl serde::Serialize for Dispatchers {
3602    #[allow(deprecated)]
3603    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3604    where
3605        S: serde::Serializer,
3606    {
3607        use serde::ser::SerializeStruct;
3608        let mut len = 0;
3609        if !self.dispatchers.is_empty() {
3610            len += 1;
3611        }
3612        let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3613        if !self.dispatchers.is_empty() {
3614            struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3615        }
3616        struct_ser.end()
3617    }
3618}
3619impl<'de> serde::Deserialize<'de> for Dispatchers {
3620    #[allow(deprecated)]
3621    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3622    where
3623        D: serde::Deserializer<'de>,
3624    {
3625        const FIELDS: &[&str] = &[
3626            "dispatchers",
3627        ];
3628
3629        #[allow(clippy::enum_variant_names)]
3630        enum GeneratedField {
3631            Dispatchers,
3632        }
3633        impl<'de> serde::Deserialize<'de> for GeneratedField {
3634            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3635            where
3636                D: serde::Deserializer<'de>,
3637            {
3638                struct GeneratedVisitor;
3639
3640                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3641                    type Value = GeneratedField;
3642
3643                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3644                        write!(formatter, "expected one of: {:?}", &FIELDS)
3645                    }
3646
3647                    #[allow(unused_variables)]
3648                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3649                    where
3650                        E: serde::de::Error,
3651                    {
3652                        match value {
3653                            "dispatchers" => Ok(GeneratedField::Dispatchers),
3654                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3655                        }
3656                    }
3657                }
3658                deserializer.deserialize_identifier(GeneratedVisitor)
3659            }
3660        }
3661        struct GeneratedVisitor;
3662        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3663            type Value = Dispatchers;
3664
3665            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3666                formatter.write_str("struct stream_plan.Dispatchers")
3667            }
3668
3669            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3670                where
3671                    V: serde::de::MapAccess<'de>,
3672            {
3673                let mut dispatchers__ = None;
3674                while let Some(k) = map_.next_key()? {
3675                    match k {
3676                        GeneratedField::Dispatchers => {
3677                            if dispatchers__.is_some() {
3678                                return Err(serde::de::Error::duplicate_field("dispatchers"));
3679                            }
3680                            dispatchers__ = Some(map_.next_value()?);
3681                        }
3682                    }
3683                }
3684                Ok(Dispatchers {
3685                    dispatchers: dispatchers__.unwrap_or_default(),
3686                })
3687            }
3688        }
3689        deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
3690    }
3691}
3692impl serde::Serialize for DmlNode {
3693    #[allow(deprecated)]
3694    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3695    where
3696        S: serde::Serializer,
3697    {
3698        use serde::ser::SerializeStruct;
3699        let mut len = 0;
3700        if self.table_id != 0 {
3701            len += 1;
3702        }
3703        if self.table_version_id != 0 {
3704            len += 1;
3705        }
3706        if !self.column_descs.is_empty() {
3707            len += 1;
3708        }
3709        if self.rate_limit.is_some() {
3710            len += 1;
3711        }
3712        let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
3713        if self.table_id != 0 {
3714            struct_ser.serialize_field("tableId", &self.table_id)?;
3715        }
3716        if self.table_version_id != 0 {
3717            #[allow(clippy::needless_borrow)]
3718            #[allow(clippy::needless_borrows_for_generic_args)]
3719            struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3720        }
3721        if !self.column_descs.is_empty() {
3722            struct_ser.serialize_field("columnDescs", &self.column_descs)?;
3723        }
3724        if let Some(v) = self.rate_limit.as_ref() {
3725            struct_ser.serialize_field("rateLimit", v)?;
3726        }
3727        struct_ser.end()
3728    }
3729}
3730impl<'de> serde::Deserialize<'de> for DmlNode {
3731    #[allow(deprecated)]
3732    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3733    where
3734        D: serde::Deserializer<'de>,
3735    {
3736        const FIELDS: &[&str] = &[
3737            "table_id",
3738            "tableId",
3739            "table_version_id",
3740            "tableVersionId",
3741            "column_descs",
3742            "columnDescs",
3743            "rate_limit",
3744            "rateLimit",
3745        ];
3746
3747        #[allow(clippy::enum_variant_names)]
3748        enum GeneratedField {
3749            TableId,
3750            TableVersionId,
3751            ColumnDescs,
3752            RateLimit,
3753        }
3754        impl<'de> serde::Deserialize<'de> for GeneratedField {
3755            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3756            where
3757                D: serde::Deserializer<'de>,
3758            {
3759                struct GeneratedVisitor;
3760
3761                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3762                    type Value = GeneratedField;
3763
3764                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3765                        write!(formatter, "expected one of: {:?}", &FIELDS)
3766                    }
3767
3768                    #[allow(unused_variables)]
3769                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3770                    where
3771                        E: serde::de::Error,
3772                    {
3773                        match value {
3774                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
3775                            "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
3776                            "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
3777                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
3778                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3779                        }
3780                    }
3781                }
3782                deserializer.deserialize_identifier(GeneratedVisitor)
3783            }
3784        }
3785        struct GeneratedVisitor;
3786        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3787            type Value = DmlNode;
3788
3789            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3790                formatter.write_str("struct stream_plan.DmlNode")
3791            }
3792
3793            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
3794                where
3795                    V: serde::de::MapAccess<'de>,
3796            {
3797                let mut table_id__ = None;
3798                let mut table_version_id__ = None;
3799                let mut column_descs__ = None;
3800                let mut rate_limit__ = None;
3801                while let Some(k) = map_.next_key()? {
3802                    match k {
3803                        GeneratedField::TableId => {
3804                            if table_id__.is_some() {
3805                                return Err(serde::de::Error::duplicate_field("tableId"));
3806                            }
3807                            table_id__ = 
3808                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3809                            ;
3810                        }
3811                        GeneratedField::TableVersionId => {
3812                            if table_version_id__.is_some() {
3813                                return Err(serde::de::Error::duplicate_field("tableVersionId"));
3814                            }
3815                            table_version_id__ = 
3816                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3817                            ;
3818                        }
3819                        GeneratedField::ColumnDescs => {
3820                            if column_descs__.is_some() {
3821                                return Err(serde::de::Error::duplicate_field("columnDescs"));
3822                            }
3823                            column_descs__ = Some(map_.next_value()?);
3824                        }
3825                        GeneratedField::RateLimit => {
3826                            if rate_limit__.is_some() {
3827                                return Err(serde::de::Error::duplicate_field("rateLimit"));
3828                            }
3829                            rate_limit__ = 
3830                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
3831                            ;
3832                        }
3833                    }
3834                }
3835                Ok(DmlNode {
3836                    table_id: table_id__.unwrap_or_default(),
3837                    table_version_id: table_version_id__.unwrap_or_default(),
3838                    column_descs: column_descs__.unwrap_or_default(),
3839                    rate_limit: rate_limit__,
3840                })
3841            }
3842        }
3843        deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
3844    }
3845}
3846impl serde::Serialize for DropSubscriptionsMutation {
3847    #[allow(deprecated)]
3848    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3849    where
3850        S: serde::Serializer,
3851    {
3852        use serde::ser::SerializeStruct;
3853        let mut len = 0;
3854        if !self.info.is_empty() {
3855            len += 1;
3856        }
3857        let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
3858        if !self.info.is_empty() {
3859            struct_ser.serialize_field("info", &self.info)?;
3860        }
3861        struct_ser.end()
3862    }
3863}
3864impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
3865    #[allow(deprecated)]
3866    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3867    where
3868        D: serde::Deserializer<'de>,
3869    {
3870        const FIELDS: &[&str] = &[
3871            "info",
3872        ];
3873
3874        #[allow(clippy::enum_variant_names)]
3875        enum GeneratedField {
3876            Info,
3877        }
3878        impl<'de> serde::Deserialize<'de> for GeneratedField {
3879            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3880            where
3881                D: serde::Deserializer<'de>,
3882            {
3883                struct GeneratedVisitor;
3884
3885                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3886                    type Value = GeneratedField;
3887
3888                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3889                        write!(formatter, "expected one of: {:?}", &FIELDS)
3890                    }
3891
3892                    #[allow(unused_variables)]
3893                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3894                    where
3895                        E: serde::de::Error,
3896                    {
3897                        match value {
3898                            "info" => Ok(GeneratedField::Info),
3899                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3900                        }
3901                    }
3902                }
3903                deserializer.deserialize_identifier(GeneratedVisitor)
3904            }
3905        }
3906        struct GeneratedVisitor;
3907        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3908            type Value = DropSubscriptionsMutation;
3909
3910            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3911                formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
3912            }
3913
3914            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
3915                where
3916                    V: serde::de::MapAccess<'de>,
3917            {
3918                let mut info__ = None;
3919                while let Some(k) = map_.next_key()? {
3920                    match k {
3921                        GeneratedField::Info => {
3922                            if info__.is_some() {
3923                                return Err(serde::de::Error::duplicate_field("info"));
3924                            }
3925                            info__ = Some(map_.next_value()?);
3926                        }
3927                    }
3928                }
3929                Ok(DropSubscriptionsMutation {
3930                    info: info__.unwrap_or_default(),
3931                })
3932            }
3933        }
3934        deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
3935    }
3936}
3937impl serde::Serialize for DynamicFilterNode {
3938    #[allow(deprecated)]
3939    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3940    where
3941        S: serde::Serializer,
3942    {
3943        use serde::ser::SerializeStruct;
3944        let mut len = 0;
3945        if self.left_key != 0 {
3946            len += 1;
3947        }
3948        if self.condition.is_some() {
3949            len += 1;
3950        }
3951        if self.left_table.is_some() {
3952            len += 1;
3953        }
3954        if self.right_table.is_some() {
3955            len += 1;
3956        }
3957        if self.condition_always_relax {
3958            len += 1;
3959        }
3960        let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
3961        if self.left_key != 0 {
3962            struct_ser.serialize_field("leftKey", &self.left_key)?;
3963        }
3964        if let Some(v) = self.condition.as_ref() {
3965            struct_ser.serialize_field("condition", v)?;
3966        }
3967        if let Some(v) = self.left_table.as_ref() {
3968            struct_ser.serialize_field("leftTable", v)?;
3969        }
3970        if let Some(v) = self.right_table.as_ref() {
3971            struct_ser.serialize_field("rightTable", v)?;
3972        }
3973        if self.condition_always_relax {
3974            struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
3975        }
3976        struct_ser.end()
3977    }
3978}
3979impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
3980    #[allow(deprecated)]
3981    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3982    where
3983        D: serde::Deserializer<'de>,
3984    {
3985        const FIELDS: &[&str] = &[
3986            "left_key",
3987            "leftKey",
3988            "condition",
3989            "left_table",
3990            "leftTable",
3991            "right_table",
3992            "rightTable",
3993            "condition_always_relax",
3994            "conditionAlwaysRelax",
3995        ];
3996
3997        #[allow(clippy::enum_variant_names)]
3998        enum GeneratedField {
3999            LeftKey,
4000            Condition,
4001            LeftTable,
4002            RightTable,
4003            ConditionAlwaysRelax,
4004        }
4005        impl<'de> serde::Deserialize<'de> for GeneratedField {
4006            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4007            where
4008                D: serde::Deserializer<'de>,
4009            {
4010                struct GeneratedVisitor;
4011
4012                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4013                    type Value = GeneratedField;
4014
4015                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4016                        write!(formatter, "expected one of: {:?}", &FIELDS)
4017                    }
4018
4019                    #[allow(unused_variables)]
4020                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4021                    where
4022                        E: serde::de::Error,
4023                    {
4024                        match value {
4025                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4026                            "condition" => Ok(GeneratedField::Condition),
4027                            "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4028                            "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4029                            "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4030                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4031                        }
4032                    }
4033                }
4034                deserializer.deserialize_identifier(GeneratedVisitor)
4035            }
4036        }
4037        struct GeneratedVisitor;
4038        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4039            type Value = DynamicFilterNode;
4040
4041            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4042                formatter.write_str("struct stream_plan.DynamicFilterNode")
4043            }
4044
4045            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4046                where
4047                    V: serde::de::MapAccess<'de>,
4048            {
4049                let mut left_key__ = None;
4050                let mut condition__ = None;
4051                let mut left_table__ = None;
4052                let mut right_table__ = None;
4053                let mut condition_always_relax__ = None;
4054                while let Some(k) = map_.next_key()? {
4055                    match k {
4056                        GeneratedField::LeftKey => {
4057                            if left_key__.is_some() {
4058                                return Err(serde::de::Error::duplicate_field("leftKey"));
4059                            }
4060                            left_key__ = 
4061                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4062                            ;
4063                        }
4064                        GeneratedField::Condition => {
4065                            if condition__.is_some() {
4066                                return Err(serde::de::Error::duplicate_field("condition"));
4067                            }
4068                            condition__ = map_.next_value()?;
4069                        }
4070                        GeneratedField::LeftTable => {
4071                            if left_table__.is_some() {
4072                                return Err(serde::de::Error::duplicate_field("leftTable"));
4073                            }
4074                            left_table__ = map_.next_value()?;
4075                        }
4076                        GeneratedField::RightTable => {
4077                            if right_table__.is_some() {
4078                                return Err(serde::de::Error::duplicate_field("rightTable"));
4079                            }
4080                            right_table__ = map_.next_value()?;
4081                        }
4082                        GeneratedField::ConditionAlwaysRelax => {
4083                            if condition_always_relax__.is_some() {
4084                                return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4085                            }
4086                            condition_always_relax__ = Some(map_.next_value()?);
4087                        }
4088                    }
4089                }
4090                Ok(DynamicFilterNode {
4091                    left_key: left_key__.unwrap_or_default(),
4092                    condition: condition__,
4093                    left_table: left_table__,
4094                    right_table: right_table__,
4095                    condition_always_relax: condition_always_relax__.unwrap_or_default(),
4096                })
4097            }
4098        }
4099        deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4100    }
4101}
4102impl serde::Serialize for EowcOverWindowNode {
4103    #[allow(deprecated)]
4104    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4105    where
4106        S: serde::Serializer,
4107    {
4108        use serde::ser::SerializeStruct;
4109        let mut len = 0;
4110        if !self.calls.is_empty() {
4111            len += 1;
4112        }
4113        if !self.partition_by.is_empty() {
4114            len += 1;
4115        }
4116        if !self.order_by.is_empty() {
4117            len += 1;
4118        }
4119        if self.state_table.is_some() {
4120            len += 1;
4121        }
4122        let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4123        if !self.calls.is_empty() {
4124            struct_ser.serialize_field("calls", &self.calls)?;
4125        }
4126        if !self.partition_by.is_empty() {
4127            struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4128        }
4129        if !self.order_by.is_empty() {
4130            struct_ser.serialize_field("orderBy", &self.order_by)?;
4131        }
4132        if let Some(v) = self.state_table.as_ref() {
4133            struct_ser.serialize_field("stateTable", v)?;
4134        }
4135        struct_ser.end()
4136    }
4137}
4138impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4139    #[allow(deprecated)]
4140    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4141    where
4142        D: serde::Deserializer<'de>,
4143    {
4144        const FIELDS: &[&str] = &[
4145            "calls",
4146            "partition_by",
4147            "partitionBy",
4148            "order_by",
4149            "orderBy",
4150            "state_table",
4151            "stateTable",
4152        ];
4153
4154        #[allow(clippy::enum_variant_names)]
4155        enum GeneratedField {
4156            Calls,
4157            PartitionBy,
4158            OrderBy,
4159            StateTable,
4160        }
4161        impl<'de> serde::Deserialize<'de> for GeneratedField {
4162            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4163            where
4164                D: serde::Deserializer<'de>,
4165            {
4166                struct GeneratedVisitor;
4167
4168                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4169                    type Value = GeneratedField;
4170
4171                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4172                        write!(formatter, "expected one of: {:?}", &FIELDS)
4173                    }
4174
4175                    #[allow(unused_variables)]
4176                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4177                    where
4178                        E: serde::de::Error,
4179                    {
4180                        match value {
4181                            "calls" => Ok(GeneratedField::Calls),
4182                            "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4183                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4184                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4185                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4186                        }
4187                    }
4188                }
4189                deserializer.deserialize_identifier(GeneratedVisitor)
4190            }
4191        }
4192        struct GeneratedVisitor;
4193        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4194            type Value = EowcOverWindowNode;
4195
4196            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4197                formatter.write_str("struct stream_plan.EowcOverWindowNode")
4198            }
4199
4200            fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4201                where
4202                    V: serde::de::MapAccess<'de>,
4203            {
4204                let mut calls__ = None;
4205                let mut partition_by__ = None;
4206                let mut order_by__ = None;
4207                let mut state_table__ = None;
4208                while let Some(k) = map_.next_key()? {
4209                    match k {
4210                        GeneratedField::Calls => {
4211                            if calls__.is_some() {
4212                                return Err(serde::de::Error::duplicate_field("calls"));
4213                            }
4214                            calls__ = Some(map_.next_value()?);
4215                        }
4216                        GeneratedField::PartitionBy => {
4217                            if partition_by__.is_some() {
4218                                return Err(serde::de::Error::duplicate_field("partitionBy"));
4219                            }
4220                            partition_by__ = 
4221                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4222                                    .into_iter().map(|x| x.0).collect())
4223                            ;
4224                        }
4225                        GeneratedField::OrderBy => {
4226                            if order_by__.is_some() {
4227                                return Err(serde::de::Error::duplicate_field("orderBy"));
4228                            }
4229                            order_by__ = Some(map_.next_value()?);
4230                        }
4231                        GeneratedField::StateTable => {
4232                            if state_table__.is_some() {
4233                                return Err(serde::de::Error::duplicate_field("stateTable"));
4234                            }
4235                            state_table__ = map_.next_value()?;
4236                        }
4237                    }
4238                }
4239                Ok(EowcOverWindowNode {
4240                    calls: calls__.unwrap_or_default(),
4241                    partition_by: partition_by__.unwrap_or_default(),
4242                    order_by: order_by__.unwrap_or_default(),
4243                    state_table: state_table__,
4244                })
4245            }
4246        }
4247        deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4248    }
4249}
4250impl serde::Serialize for ExchangeNode {
4251    #[allow(deprecated)]
4252    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4253    where
4254        S: serde::Serializer,
4255    {
4256        use serde::ser::SerializeStruct;
4257        let mut len = 0;
4258        if self.strategy.is_some() {
4259            len += 1;
4260        }
4261        let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4262        if let Some(v) = self.strategy.as_ref() {
4263            struct_ser.serialize_field("strategy", v)?;
4264        }
4265        struct_ser.end()
4266    }
4267}
4268impl<'de> serde::Deserialize<'de> for ExchangeNode {
4269    #[allow(deprecated)]
4270    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4271    where
4272        D: serde::Deserializer<'de>,
4273    {
4274        const FIELDS: &[&str] = &[
4275            "strategy",
4276        ];
4277
4278        #[allow(clippy::enum_variant_names)]
4279        enum GeneratedField {
4280            Strategy,
4281        }
4282        impl<'de> serde::Deserialize<'de> for GeneratedField {
4283            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4284            where
4285                D: serde::Deserializer<'de>,
4286            {
4287                struct GeneratedVisitor;
4288
4289                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4290                    type Value = GeneratedField;
4291
4292                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4293                        write!(formatter, "expected one of: {:?}", &FIELDS)
4294                    }
4295
4296                    #[allow(unused_variables)]
4297                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4298                    where
4299                        E: serde::de::Error,
4300                    {
4301                        match value {
4302                            "strategy" => Ok(GeneratedField::Strategy),
4303                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4304                        }
4305                    }
4306                }
4307                deserializer.deserialize_identifier(GeneratedVisitor)
4308            }
4309        }
4310        struct GeneratedVisitor;
4311        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4312            type Value = ExchangeNode;
4313
4314            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4315                formatter.write_str("struct stream_plan.ExchangeNode")
4316            }
4317
4318            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4319                where
4320                    V: serde::de::MapAccess<'de>,
4321            {
4322                let mut strategy__ = None;
4323                while let Some(k) = map_.next_key()? {
4324                    match k {
4325                        GeneratedField::Strategy => {
4326                            if strategy__.is_some() {
4327                                return Err(serde::de::Error::duplicate_field("strategy"));
4328                            }
4329                            strategy__ = map_.next_value()?;
4330                        }
4331                    }
4332                }
4333                Ok(ExchangeNode {
4334                    strategy: strategy__,
4335                })
4336            }
4337        }
4338        deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4339    }
4340}
4341impl serde::Serialize for ExpandNode {
4342    #[allow(deprecated)]
4343    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4344    where
4345        S: serde::Serializer,
4346    {
4347        use serde::ser::SerializeStruct;
4348        let mut len = 0;
4349        if !self.column_subsets.is_empty() {
4350            len += 1;
4351        }
4352        let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4353        if !self.column_subsets.is_empty() {
4354            struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4355        }
4356        struct_ser.end()
4357    }
4358}
4359impl<'de> serde::Deserialize<'de> for ExpandNode {
4360    #[allow(deprecated)]
4361    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4362    where
4363        D: serde::Deserializer<'de>,
4364    {
4365        const FIELDS: &[&str] = &[
4366            "column_subsets",
4367            "columnSubsets",
4368        ];
4369
4370        #[allow(clippy::enum_variant_names)]
4371        enum GeneratedField {
4372            ColumnSubsets,
4373        }
4374        impl<'de> serde::Deserialize<'de> for GeneratedField {
4375            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4376            where
4377                D: serde::Deserializer<'de>,
4378            {
4379                struct GeneratedVisitor;
4380
4381                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4382                    type Value = GeneratedField;
4383
4384                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4385                        write!(formatter, "expected one of: {:?}", &FIELDS)
4386                    }
4387
4388                    #[allow(unused_variables)]
4389                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4390                    where
4391                        E: serde::de::Error,
4392                    {
4393                        match value {
4394                            "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4395                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4396                        }
4397                    }
4398                }
4399                deserializer.deserialize_identifier(GeneratedVisitor)
4400            }
4401        }
4402        struct GeneratedVisitor;
4403        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4404            type Value = ExpandNode;
4405
4406            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4407                formatter.write_str("struct stream_plan.ExpandNode")
4408            }
4409
4410            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4411                where
4412                    V: serde::de::MapAccess<'de>,
4413            {
4414                let mut column_subsets__ = None;
4415                while let Some(k) = map_.next_key()? {
4416                    match k {
4417                        GeneratedField::ColumnSubsets => {
4418                            if column_subsets__.is_some() {
4419                                return Err(serde::de::Error::duplicate_field("columnSubsets"));
4420                            }
4421                            column_subsets__ = Some(map_.next_value()?);
4422                        }
4423                    }
4424                }
4425                Ok(ExpandNode {
4426                    column_subsets: column_subsets__.unwrap_or_default(),
4427                })
4428            }
4429        }
4430        deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4431    }
4432}
4433impl serde::Serialize for expand_node::Subset {
4434    #[allow(deprecated)]
4435    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4436    where
4437        S: serde::Serializer,
4438    {
4439        use serde::ser::SerializeStruct;
4440        let mut len = 0;
4441        if !self.column_indices.is_empty() {
4442            len += 1;
4443        }
4444        let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4445        if !self.column_indices.is_empty() {
4446            struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4447        }
4448        struct_ser.end()
4449    }
4450}
4451impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4452    #[allow(deprecated)]
4453    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4454    where
4455        D: serde::Deserializer<'de>,
4456    {
4457        const FIELDS: &[&str] = &[
4458            "column_indices",
4459            "columnIndices",
4460        ];
4461
4462        #[allow(clippy::enum_variant_names)]
4463        enum GeneratedField {
4464            ColumnIndices,
4465        }
4466        impl<'de> serde::Deserialize<'de> for GeneratedField {
4467            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4468            where
4469                D: serde::Deserializer<'de>,
4470            {
4471                struct GeneratedVisitor;
4472
4473                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4474                    type Value = GeneratedField;
4475
4476                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4477                        write!(formatter, "expected one of: {:?}", &FIELDS)
4478                    }
4479
4480                    #[allow(unused_variables)]
4481                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4482                    where
4483                        E: serde::de::Error,
4484                    {
4485                        match value {
4486                            "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4487                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4488                        }
4489                    }
4490                }
4491                deserializer.deserialize_identifier(GeneratedVisitor)
4492            }
4493        }
4494        struct GeneratedVisitor;
4495        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4496            type Value = expand_node::Subset;
4497
4498            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4499                formatter.write_str("struct stream_plan.ExpandNode.Subset")
4500            }
4501
4502            fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
4503                where
4504                    V: serde::de::MapAccess<'de>,
4505            {
4506                let mut column_indices__ = None;
4507                while let Some(k) = map_.next_key()? {
4508                    match k {
4509                        GeneratedField::ColumnIndices => {
4510                            if column_indices__.is_some() {
4511                                return Err(serde::de::Error::duplicate_field("columnIndices"));
4512                            }
4513                            column_indices__ = 
4514                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4515                                    .into_iter().map(|x| x.0).collect())
4516                            ;
4517                        }
4518                    }
4519                }
4520                Ok(expand_node::Subset {
4521                    column_indices: column_indices__.unwrap_or_default(),
4522                })
4523            }
4524        }
4525        deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
4526    }
4527}
4528impl serde::Serialize for FilterNode {
4529    #[allow(deprecated)]
4530    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4531    where
4532        S: serde::Serializer,
4533    {
4534        use serde::ser::SerializeStruct;
4535        let mut len = 0;
4536        if self.search_condition.is_some() {
4537            len += 1;
4538        }
4539        let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
4540        if let Some(v) = self.search_condition.as_ref() {
4541            struct_ser.serialize_field("searchCondition", v)?;
4542        }
4543        struct_ser.end()
4544    }
4545}
4546impl<'de> serde::Deserialize<'de> for FilterNode {
4547    #[allow(deprecated)]
4548    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4549    where
4550        D: serde::Deserializer<'de>,
4551    {
4552        const FIELDS: &[&str] = &[
4553            "search_condition",
4554            "searchCondition",
4555        ];
4556
4557        #[allow(clippy::enum_variant_names)]
4558        enum GeneratedField {
4559            SearchCondition,
4560        }
4561        impl<'de> serde::Deserialize<'de> for GeneratedField {
4562            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4563            where
4564                D: serde::Deserializer<'de>,
4565            {
4566                struct GeneratedVisitor;
4567
4568                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4569                    type Value = GeneratedField;
4570
4571                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4572                        write!(formatter, "expected one of: {:?}", &FIELDS)
4573                    }
4574
4575                    #[allow(unused_variables)]
4576                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4577                    where
4578                        E: serde::de::Error,
4579                    {
4580                        match value {
4581                            "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
4582                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4583                        }
4584                    }
4585                }
4586                deserializer.deserialize_identifier(GeneratedVisitor)
4587            }
4588        }
4589        struct GeneratedVisitor;
4590        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4591            type Value = FilterNode;
4592
4593            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4594                formatter.write_str("struct stream_plan.FilterNode")
4595            }
4596
4597            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
4598                where
4599                    V: serde::de::MapAccess<'de>,
4600            {
4601                let mut search_condition__ = None;
4602                while let Some(k) = map_.next_key()? {
4603                    match k {
4604                        GeneratedField::SearchCondition => {
4605                            if search_condition__.is_some() {
4606                                return Err(serde::de::Error::duplicate_field("searchCondition"));
4607                            }
4608                            search_condition__ = map_.next_value()?;
4609                        }
4610                    }
4611                }
4612                Ok(FilterNode {
4613                    search_condition: search_condition__,
4614                })
4615            }
4616        }
4617        deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
4618    }
4619}
4620impl serde::Serialize for GlobalApproxPercentileNode {
4621    #[allow(deprecated)]
4622    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4623    where
4624        S: serde::Serializer,
4625    {
4626        use serde::ser::SerializeStruct;
4627        let mut len = 0;
4628        if self.base != 0. {
4629            len += 1;
4630        }
4631        if self.quantile != 0. {
4632            len += 1;
4633        }
4634        if self.bucket_state_table.is_some() {
4635            len += 1;
4636        }
4637        if self.count_state_table.is_some() {
4638            len += 1;
4639        }
4640        let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
4641        if self.base != 0. {
4642            struct_ser.serialize_field("base", &self.base)?;
4643        }
4644        if self.quantile != 0. {
4645            struct_ser.serialize_field("quantile", &self.quantile)?;
4646        }
4647        if let Some(v) = self.bucket_state_table.as_ref() {
4648            struct_ser.serialize_field("bucketStateTable", v)?;
4649        }
4650        if let Some(v) = self.count_state_table.as_ref() {
4651            struct_ser.serialize_field("countStateTable", v)?;
4652        }
4653        struct_ser.end()
4654    }
4655}
4656impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
4657    #[allow(deprecated)]
4658    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4659    where
4660        D: serde::Deserializer<'de>,
4661    {
4662        const FIELDS: &[&str] = &[
4663            "base",
4664            "quantile",
4665            "bucket_state_table",
4666            "bucketStateTable",
4667            "count_state_table",
4668            "countStateTable",
4669        ];
4670
4671        #[allow(clippy::enum_variant_names)]
4672        enum GeneratedField {
4673            Base,
4674            Quantile,
4675            BucketStateTable,
4676            CountStateTable,
4677        }
4678        impl<'de> serde::Deserialize<'de> for GeneratedField {
4679            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4680            where
4681                D: serde::Deserializer<'de>,
4682            {
4683                struct GeneratedVisitor;
4684
4685                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4686                    type Value = GeneratedField;
4687
4688                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4689                        write!(formatter, "expected one of: {:?}", &FIELDS)
4690                    }
4691
4692                    #[allow(unused_variables)]
4693                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4694                    where
4695                        E: serde::de::Error,
4696                    {
4697                        match value {
4698                            "base" => Ok(GeneratedField::Base),
4699                            "quantile" => Ok(GeneratedField::Quantile),
4700                            "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
4701                            "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
4702                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4703                        }
4704                    }
4705                }
4706                deserializer.deserialize_identifier(GeneratedVisitor)
4707            }
4708        }
4709        struct GeneratedVisitor;
4710        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4711            type Value = GlobalApproxPercentileNode;
4712
4713            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4714                formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
4715            }
4716
4717            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
4718                where
4719                    V: serde::de::MapAccess<'de>,
4720            {
4721                let mut base__ = None;
4722                let mut quantile__ = None;
4723                let mut bucket_state_table__ = None;
4724                let mut count_state_table__ = None;
4725                while let Some(k) = map_.next_key()? {
4726                    match k {
4727                        GeneratedField::Base => {
4728                            if base__.is_some() {
4729                                return Err(serde::de::Error::duplicate_field("base"));
4730                            }
4731                            base__ = 
4732                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4733                            ;
4734                        }
4735                        GeneratedField::Quantile => {
4736                            if quantile__.is_some() {
4737                                return Err(serde::de::Error::duplicate_field("quantile"));
4738                            }
4739                            quantile__ = 
4740                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4741                            ;
4742                        }
4743                        GeneratedField::BucketStateTable => {
4744                            if bucket_state_table__.is_some() {
4745                                return Err(serde::de::Error::duplicate_field("bucketStateTable"));
4746                            }
4747                            bucket_state_table__ = map_.next_value()?;
4748                        }
4749                        GeneratedField::CountStateTable => {
4750                            if count_state_table__.is_some() {
4751                                return Err(serde::de::Error::duplicate_field("countStateTable"));
4752                            }
4753                            count_state_table__ = map_.next_value()?;
4754                        }
4755                    }
4756                }
4757                Ok(GlobalApproxPercentileNode {
4758                    base: base__.unwrap_or_default(),
4759                    quantile: quantile__.unwrap_or_default(),
4760                    bucket_state_table: bucket_state_table__,
4761                    count_state_table: count_state_table__,
4762                })
4763            }
4764        }
4765        deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
4766    }
4767}
4768impl serde::Serialize for GroupTopNNode {
4769    #[allow(deprecated)]
4770    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4771    where
4772        S: serde::Serializer,
4773    {
4774        use serde::ser::SerializeStruct;
4775        let mut len = 0;
4776        if self.limit != 0 {
4777            len += 1;
4778        }
4779        if self.offset != 0 {
4780            len += 1;
4781        }
4782        if !self.group_key.is_empty() {
4783            len += 1;
4784        }
4785        if self.table.is_some() {
4786            len += 1;
4787        }
4788        if !self.order_by.is_empty() {
4789            len += 1;
4790        }
4791        if self.with_ties {
4792            len += 1;
4793        }
4794        let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
4795        if self.limit != 0 {
4796            #[allow(clippy::needless_borrow)]
4797            #[allow(clippy::needless_borrows_for_generic_args)]
4798            struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
4799        }
4800        if self.offset != 0 {
4801            #[allow(clippy::needless_borrow)]
4802            #[allow(clippy::needless_borrows_for_generic_args)]
4803            struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
4804        }
4805        if !self.group_key.is_empty() {
4806            struct_ser.serialize_field("groupKey", &self.group_key)?;
4807        }
4808        if let Some(v) = self.table.as_ref() {
4809            struct_ser.serialize_field("table", v)?;
4810        }
4811        if !self.order_by.is_empty() {
4812            struct_ser.serialize_field("orderBy", &self.order_by)?;
4813        }
4814        if self.with_ties {
4815            struct_ser.serialize_field("withTies", &self.with_ties)?;
4816        }
4817        struct_ser.end()
4818    }
4819}
4820impl<'de> serde::Deserialize<'de> for GroupTopNNode {
4821    #[allow(deprecated)]
4822    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4823    where
4824        D: serde::Deserializer<'de>,
4825    {
4826        const FIELDS: &[&str] = &[
4827            "limit",
4828            "offset",
4829            "group_key",
4830            "groupKey",
4831            "table",
4832            "order_by",
4833            "orderBy",
4834            "with_ties",
4835            "withTies",
4836        ];
4837
4838        #[allow(clippy::enum_variant_names)]
4839        enum GeneratedField {
4840            Limit,
4841            Offset,
4842            GroupKey,
4843            Table,
4844            OrderBy,
4845            WithTies,
4846        }
4847        impl<'de> serde::Deserialize<'de> for GeneratedField {
4848            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4849            where
4850                D: serde::Deserializer<'de>,
4851            {
4852                struct GeneratedVisitor;
4853
4854                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4855                    type Value = GeneratedField;
4856
4857                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4858                        write!(formatter, "expected one of: {:?}", &FIELDS)
4859                    }
4860
4861                    #[allow(unused_variables)]
4862                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4863                    where
4864                        E: serde::de::Error,
4865                    {
4866                        match value {
4867                            "limit" => Ok(GeneratedField::Limit),
4868                            "offset" => Ok(GeneratedField::Offset),
4869                            "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
4870                            "table" => Ok(GeneratedField::Table),
4871                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4872                            "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
4873                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4874                        }
4875                    }
4876                }
4877                deserializer.deserialize_identifier(GeneratedVisitor)
4878            }
4879        }
4880        struct GeneratedVisitor;
4881        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4882            type Value = GroupTopNNode;
4883
4884            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4885                formatter.write_str("struct stream_plan.GroupTopNNode")
4886            }
4887
4888            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
4889                where
4890                    V: serde::de::MapAccess<'de>,
4891            {
4892                let mut limit__ = None;
4893                let mut offset__ = None;
4894                let mut group_key__ = None;
4895                let mut table__ = None;
4896                let mut order_by__ = None;
4897                let mut with_ties__ = None;
4898                while let Some(k) = map_.next_key()? {
4899                    match k {
4900                        GeneratedField::Limit => {
4901                            if limit__.is_some() {
4902                                return Err(serde::de::Error::duplicate_field("limit"));
4903                            }
4904                            limit__ = 
4905                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4906                            ;
4907                        }
4908                        GeneratedField::Offset => {
4909                            if offset__.is_some() {
4910                                return Err(serde::de::Error::duplicate_field("offset"));
4911                            }
4912                            offset__ = 
4913                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4914                            ;
4915                        }
4916                        GeneratedField::GroupKey => {
4917                            if group_key__.is_some() {
4918                                return Err(serde::de::Error::duplicate_field("groupKey"));
4919                            }
4920                            group_key__ = 
4921                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4922                                    .into_iter().map(|x| x.0).collect())
4923                            ;
4924                        }
4925                        GeneratedField::Table => {
4926                            if table__.is_some() {
4927                                return Err(serde::de::Error::duplicate_field("table"));
4928                            }
4929                            table__ = map_.next_value()?;
4930                        }
4931                        GeneratedField::OrderBy => {
4932                            if order_by__.is_some() {
4933                                return Err(serde::de::Error::duplicate_field("orderBy"));
4934                            }
4935                            order_by__ = Some(map_.next_value()?);
4936                        }
4937                        GeneratedField::WithTies => {
4938                            if with_ties__.is_some() {
4939                                return Err(serde::de::Error::duplicate_field("withTies"));
4940                            }
4941                            with_ties__ = Some(map_.next_value()?);
4942                        }
4943                    }
4944                }
4945                Ok(GroupTopNNode {
4946                    limit: limit__.unwrap_or_default(),
4947                    offset: offset__.unwrap_or_default(),
4948                    group_key: group_key__.unwrap_or_default(),
4949                    table: table__,
4950                    order_by: order_by__.unwrap_or_default(),
4951                    with_ties: with_ties__.unwrap_or_default(),
4952                })
4953            }
4954        }
4955        deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
4956    }
4957}
4958impl serde::Serialize for HashAggNode {
4959    #[allow(deprecated)]
4960    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4961    where
4962        S: serde::Serializer,
4963    {
4964        use serde::ser::SerializeStruct;
4965        let mut len = 0;
4966        if !self.group_key.is_empty() {
4967            len += 1;
4968        }
4969        if !self.agg_calls.is_empty() {
4970            len += 1;
4971        }
4972        if !self.agg_call_states.is_empty() {
4973            len += 1;
4974        }
4975        if self.intermediate_state_table.is_some() {
4976            len += 1;
4977        }
4978        if self.is_append_only {
4979            len += 1;
4980        }
4981        if !self.distinct_dedup_tables.is_empty() {
4982            len += 1;
4983        }
4984        if self.row_count_index != 0 {
4985            len += 1;
4986        }
4987        if self.emit_on_window_close {
4988            len += 1;
4989        }
4990        if self.version != 0 {
4991            len += 1;
4992        }
4993        let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
4994        if !self.group_key.is_empty() {
4995            struct_ser.serialize_field("groupKey", &self.group_key)?;
4996        }
4997        if !self.agg_calls.is_empty() {
4998            struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
4999        }
5000        if !self.agg_call_states.is_empty() {
5001            struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5002        }
5003        if let Some(v) = self.intermediate_state_table.as_ref() {
5004            struct_ser.serialize_field("intermediateStateTable", v)?;
5005        }
5006        if self.is_append_only {
5007            struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5008        }
5009        if !self.distinct_dedup_tables.is_empty() {
5010            struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5011        }
5012        if self.row_count_index != 0 {
5013            struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5014        }
5015        if self.emit_on_window_close {
5016            struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5017        }
5018        if self.version != 0 {
5019            let v = AggNodeVersion::try_from(self.version)
5020                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5021            struct_ser.serialize_field("version", &v)?;
5022        }
5023        struct_ser.end()
5024    }
5025}
5026impl<'de> serde::Deserialize<'de> for HashAggNode {
5027    #[allow(deprecated)]
5028    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5029    where
5030        D: serde::Deserializer<'de>,
5031    {
5032        const FIELDS: &[&str] = &[
5033            "group_key",
5034            "groupKey",
5035            "agg_calls",
5036            "aggCalls",
5037            "agg_call_states",
5038            "aggCallStates",
5039            "intermediate_state_table",
5040            "intermediateStateTable",
5041            "is_append_only",
5042            "isAppendOnly",
5043            "distinct_dedup_tables",
5044            "distinctDedupTables",
5045            "row_count_index",
5046            "rowCountIndex",
5047            "emit_on_window_close",
5048            "emitOnWindowClose",
5049            "version",
5050        ];
5051
5052        #[allow(clippy::enum_variant_names)]
5053        enum GeneratedField {
5054            GroupKey,
5055            AggCalls,
5056            AggCallStates,
5057            IntermediateStateTable,
5058            IsAppendOnly,
5059            DistinctDedupTables,
5060            RowCountIndex,
5061            EmitOnWindowClose,
5062            Version,
5063        }
5064        impl<'de> serde::Deserialize<'de> for GeneratedField {
5065            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5066            where
5067                D: serde::Deserializer<'de>,
5068            {
5069                struct GeneratedVisitor;
5070
5071                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5072                    type Value = GeneratedField;
5073
5074                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5075                        write!(formatter, "expected one of: {:?}", &FIELDS)
5076                    }
5077
5078                    #[allow(unused_variables)]
5079                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5080                    where
5081                        E: serde::de::Error,
5082                    {
5083                        match value {
5084                            "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5085                            "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
5086                            "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
5087                            "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5088                            "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5089                            "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
5090                            "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
5091                            "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
5092                            "version" => Ok(GeneratedField::Version),
5093                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5094                        }
5095                    }
5096                }
5097                deserializer.deserialize_identifier(GeneratedVisitor)
5098            }
5099        }
5100        struct GeneratedVisitor;
5101        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5102            type Value = HashAggNode;
5103
5104            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5105                formatter.write_str("struct stream_plan.HashAggNode")
5106            }
5107
5108            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5109                where
5110                    V: serde::de::MapAccess<'de>,
5111            {
5112                let mut group_key__ = None;
5113                let mut agg_calls__ = None;
5114                let mut agg_call_states__ = None;
5115                let mut intermediate_state_table__ = None;
5116                let mut is_append_only__ = None;
5117                let mut distinct_dedup_tables__ = None;
5118                let mut row_count_index__ = None;
5119                let mut emit_on_window_close__ = None;
5120                let mut version__ = None;
5121                while let Some(k) = map_.next_key()? {
5122                    match k {
5123                        GeneratedField::GroupKey => {
5124                            if group_key__.is_some() {
5125                                return Err(serde::de::Error::duplicate_field("groupKey"));
5126                            }
5127                            group_key__ = 
5128                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5129                                    .into_iter().map(|x| x.0).collect())
5130                            ;
5131                        }
5132                        GeneratedField::AggCalls => {
5133                            if agg_calls__.is_some() {
5134                                return Err(serde::de::Error::duplicate_field("aggCalls"));
5135                            }
5136                            agg_calls__ = Some(map_.next_value()?);
5137                        }
5138                        GeneratedField::AggCallStates => {
5139                            if agg_call_states__.is_some() {
5140                                return Err(serde::de::Error::duplicate_field("aggCallStates"));
5141                            }
5142                            agg_call_states__ = Some(map_.next_value()?);
5143                        }
5144                        GeneratedField::IntermediateStateTable => {
5145                            if intermediate_state_table__.is_some() {
5146                                return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5147                            }
5148                            intermediate_state_table__ = map_.next_value()?;
5149                        }
5150                        GeneratedField::IsAppendOnly => {
5151                            if is_append_only__.is_some() {
5152                                return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5153                            }
5154                            is_append_only__ = Some(map_.next_value()?);
5155                        }
5156                        GeneratedField::DistinctDedupTables => {
5157                            if distinct_dedup_tables__.is_some() {
5158                                return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5159                            }
5160                            distinct_dedup_tables__ = Some(
5161                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5162                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
5163                            );
5164                        }
5165                        GeneratedField::RowCountIndex => {
5166                            if row_count_index__.is_some() {
5167                                return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5168                            }
5169                            row_count_index__ = 
5170                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5171                            ;
5172                        }
5173                        GeneratedField::EmitOnWindowClose => {
5174                            if emit_on_window_close__.is_some() {
5175                                return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5176                            }
5177                            emit_on_window_close__ = Some(map_.next_value()?);
5178                        }
5179                        GeneratedField::Version => {
5180                            if version__.is_some() {
5181                                return Err(serde::de::Error::duplicate_field("version"));
5182                            }
5183                            version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5184                        }
5185                    }
5186                }
5187                Ok(HashAggNode {
5188                    group_key: group_key__.unwrap_or_default(),
5189                    agg_calls: agg_calls__.unwrap_or_default(),
5190                    agg_call_states: agg_call_states__.unwrap_or_default(),
5191                    intermediate_state_table: intermediate_state_table__,
5192                    is_append_only: is_append_only__.unwrap_or_default(),
5193                    distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5194                    row_count_index: row_count_index__.unwrap_or_default(),
5195                    emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5196                    version: version__.unwrap_or_default(),
5197                })
5198            }
5199        }
5200        deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5201    }
5202}
5203impl serde::Serialize for HashJoinNode {
5204    #[allow(deprecated)]
5205    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5206    where
5207        S: serde::Serializer,
5208    {
5209        use serde::ser::SerializeStruct;
5210        let mut len = 0;
5211        if self.join_type != 0 {
5212            len += 1;
5213        }
5214        if !self.left_key.is_empty() {
5215            len += 1;
5216        }
5217        if !self.right_key.is_empty() {
5218            len += 1;
5219        }
5220        if self.condition.is_some() {
5221            len += 1;
5222        }
5223        if !self.inequality_pairs.is_empty() {
5224            len += 1;
5225        }
5226        if self.left_table.is_some() {
5227            len += 1;
5228        }
5229        if self.right_table.is_some() {
5230            len += 1;
5231        }
5232        if self.left_degree_table.is_some() {
5233            len += 1;
5234        }
5235        if self.right_degree_table.is_some() {
5236            len += 1;
5237        }
5238        if !self.output_indices.is_empty() {
5239            len += 1;
5240        }
5241        if !self.left_deduped_input_pk_indices.is_empty() {
5242            len += 1;
5243        }
5244        if !self.right_deduped_input_pk_indices.is_empty() {
5245            len += 1;
5246        }
5247        if !self.null_safe.is_empty() {
5248            len += 1;
5249        }
5250        if self.is_append_only {
5251            len += 1;
5252        }
5253        let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5254        if self.join_type != 0 {
5255            let v = super::plan_common::JoinType::try_from(self.join_type)
5256                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5257            struct_ser.serialize_field("joinType", &v)?;
5258        }
5259        if !self.left_key.is_empty() {
5260            struct_ser.serialize_field("leftKey", &self.left_key)?;
5261        }
5262        if !self.right_key.is_empty() {
5263            struct_ser.serialize_field("rightKey", &self.right_key)?;
5264        }
5265        if let Some(v) = self.condition.as_ref() {
5266            struct_ser.serialize_field("condition", v)?;
5267        }
5268        if !self.inequality_pairs.is_empty() {
5269            struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
5270        }
5271        if let Some(v) = self.left_table.as_ref() {
5272            struct_ser.serialize_field("leftTable", v)?;
5273        }
5274        if let Some(v) = self.right_table.as_ref() {
5275            struct_ser.serialize_field("rightTable", v)?;
5276        }
5277        if let Some(v) = self.left_degree_table.as_ref() {
5278            struct_ser.serialize_field("leftDegreeTable", v)?;
5279        }
5280        if let Some(v) = self.right_degree_table.as_ref() {
5281            struct_ser.serialize_field("rightDegreeTable", v)?;
5282        }
5283        if !self.output_indices.is_empty() {
5284            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5285        }
5286        if !self.left_deduped_input_pk_indices.is_empty() {
5287            struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
5288        }
5289        if !self.right_deduped_input_pk_indices.is_empty() {
5290            struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
5291        }
5292        if !self.null_safe.is_empty() {
5293            struct_ser.serialize_field("nullSafe", &self.null_safe)?;
5294        }
5295        if self.is_append_only {
5296            struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5297        }
5298        struct_ser.end()
5299    }
5300}
5301impl<'de> serde::Deserialize<'de> for HashJoinNode {
5302    #[allow(deprecated)]
5303    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5304    where
5305        D: serde::Deserializer<'de>,
5306    {
5307        const FIELDS: &[&str] = &[
5308            "join_type",
5309            "joinType",
5310            "left_key",
5311            "leftKey",
5312            "right_key",
5313            "rightKey",
5314            "condition",
5315            "inequality_pairs",
5316            "inequalityPairs",
5317            "left_table",
5318            "leftTable",
5319            "right_table",
5320            "rightTable",
5321            "left_degree_table",
5322            "leftDegreeTable",
5323            "right_degree_table",
5324            "rightDegreeTable",
5325            "output_indices",
5326            "outputIndices",
5327            "left_deduped_input_pk_indices",
5328            "leftDedupedInputPkIndices",
5329            "right_deduped_input_pk_indices",
5330            "rightDedupedInputPkIndices",
5331            "null_safe",
5332            "nullSafe",
5333            "is_append_only",
5334            "isAppendOnly",
5335        ];
5336
5337        #[allow(clippy::enum_variant_names)]
5338        enum GeneratedField {
5339            JoinType,
5340            LeftKey,
5341            RightKey,
5342            Condition,
5343            InequalityPairs,
5344            LeftTable,
5345            RightTable,
5346            LeftDegreeTable,
5347            RightDegreeTable,
5348            OutputIndices,
5349            LeftDedupedInputPkIndices,
5350            RightDedupedInputPkIndices,
5351            NullSafe,
5352            IsAppendOnly,
5353        }
5354        impl<'de> serde::Deserialize<'de> for GeneratedField {
5355            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5356            where
5357                D: serde::Deserializer<'de>,
5358            {
5359                struct GeneratedVisitor;
5360
5361                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5362                    type Value = GeneratedField;
5363
5364                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5365                        write!(formatter, "expected one of: {:?}", &FIELDS)
5366                    }
5367
5368                    #[allow(unused_variables)]
5369                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5370                    where
5371                        E: serde::de::Error,
5372                    {
5373                        match value {
5374                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
5375                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
5376                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
5377                            "condition" => Ok(GeneratedField::Condition),
5378                            "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
5379                            "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
5380                            "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
5381                            "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
5382                            "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
5383                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5384                            "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
5385                            "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
5386                            "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
5387                            "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5388                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5389                        }
5390                    }
5391                }
5392                deserializer.deserialize_identifier(GeneratedVisitor)
5393            }
5394        }
5395        struct GeneratedVisitor;
5396        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5397            type Value = HashJoinNode;
5398
5399            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5400                formatter.write_str("struct stream_plan.HashJoinNode")
5401            }
5402
5403            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
5404                where
5405                    V: serde::de::MapAccess<'de>,
5406            {
5407                let mut join_type__ = None;
5408                let mut left_key__ = None;
5409                let mut right_key__ = None;
5410                let mut condition__ = None;
5411                let mut inequality_pairs__ = None;
5412                let mut left_table__ = None;
5413                let mut right_table__ = None;
5414                let mut left_degree_table__ = None;
5415                let mut right_degree_table__ = None;
5416                let mut output_indices__ = None;
5417                let mut left_deduped_input_pk_indices__ = None;
5418                let mut right_deduped_input_pk_indices__ = None;
5419                let mut null_safe__ = None;
5420                let mut is_append_only__ = None;
5421                while let Some(k) = map_.next_key()? {
5422                    match k {
5423                        GeneratedField::JoinType => {
5424                            if join_type__.is_some() {
5425                                return Err(serde::de::Error::duplicate_field("joinType"));
5426                            }
5427                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
5428                        }
5429                        GeneratedField::LeftKey => {
5430                            if left_key__.is_some() {
5431                                return Err(serde::de::Error::duplicate_field("leftKey"));
5432                            }
5433                            left_key__ = 
5434                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5435                                    .into_iter().map(|x| x.0).collect())
5436                            ;
5437                        }
5438                        GeneratedField::RightKey => {
5439                            if right_key__.is_some() {
5440                                return Err(serde::de::Error::duplicate_field("rightKey"));
5441                            }
5442                            right_key__ = 
5443                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5444                                    .into_iter().map(|x| x.0).collect())
5445                            ;
5446                        }
5447                        GeneratedField::Condition => {
5448                            if condition__.is_some() {
5449                                return Err(serde::de::Error::duplicate_field("condition"));
5450                            }
5451                            condition__ = map_.next_value()?;
5452                        }
5453                        GeneratedField::InequalityPairs => {
5454                            if inequality_pairs__.is_some() {
5455                                return Err(serde::de::Error::duplicate_field("inequalityPairs"));
5456                            }
5457                            inequality_pairs__ = Some(map_.next_value()?);
5458                        }
5459                        GeneratedField::LeftTable => {
5460                            if left_table__.is_some() {
5461                                return Err(serde::de::Error::duplicate_field("leftTable"));
5462                            }
5463                            left_table__ = map_.next_value()?;
5464                        }
5465                        GeneratedField::RightTable => {
5466                            if right_table__.is_some() {
5467                                return Err(serde::de::Error::duplicate_field("rightTable"));
5468                            }
5469                            right_table__ = map_.next_value()?;
5470                        }
5471                        GeneratedField::LeftDegreeTable => {
5472                            if left_degree_table__.is_some() {
5473                                return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
5474                            }
5475                            left_degree_table__ = map_.next_value()?;
5476                        }
5477                        GeneratedField::RightDegreeTable => {
5478                            if right_degree_table__.is_some() {
5479                                return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
5480                            }
5481                            right_degree_table__ = map_.next_value()?;
5482                        }
5483                        GeneratedField::OutputIndices => {
5484                            if output_indices__.is_some() {
5485                                return Err(serde::de::Error::duplicate_field("outputIndices"));
5486                            }
5487                            output_indices__ = 
5488                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5489                                    .into_iter().map(|x| x.0).collect())
5490                            ;
5491                        }
5492                        GeneratedField::LeftDedupedInputPkIndices => {
5493                            if left_deduped_input_pk_indices__.is_some() {
5494                                return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
5495                            }
5496                            left_deduped_input_pk_indices__ = 
5497                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5498                                    .into_iter().map(|x| x.0).collect())
5499                            ;
5500                        }
5501                        GeneratedField::RightDedupedInputPkIndices => {
5502                            if right_deduped_input_pk_indices__.is_some() {
5503                                return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
5504                            }
5505                            right_deduped_input_pk_indices__ = 
5506                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5507                                    .into_iter().map(|x| x.0).collect())
5508                            ;
5509                        }
5510                        GeneratedField::NullSafe => {
5511                            if null_safe__.is_some() {
5512                                return Err(serde::de::Error::duplicate_field("nullSafe"));
5513                            }
5514                            null_safe__ = Some(map_.next_value()?);
5515                        }
5516                        GeneratedField::IsAppendOnly => {
5517                            if is_append_only__.is_some() {
5518                                return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5519                            }
5520                            is_append_only__ = Some(map_.next_value()?);
5521                        }
5522                    }
5523                }
5524                Ok(HashJoinNode {
5525                    join_type: join_type__.unwrap_or_default(),
5526                    left_key: left_key__.unwrap_or_default(),
5527                    right_key: right_key__.unwrap_or_default(),
5528                    condition: condition__,
5529                    inequality_pairs: inequality_pairs__.unwrap_or_default(),
5530                    left_table: left_table__,
5531                    right_table: right_table__,
5532                    left_degree_table: left_degree_table__,
5533                    right_degree_table: right_degree_table__,
5534                    output_indices: output_indices__.unwrap_or_default(),
5535                    left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
5536                    right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
5537                    null_safe: null_safe__.unwrap_or_default(),
5538                    is_append_only: is_append_only__.unwrap_or_default(),
5539                })
5540            }
5541        }
5542        deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
5543    }
5544}
5545impl serde::Serialize for HopWindowNode {
5546    #[allow(deprecated)]
5547    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5548    where
5549        S: serde::Serializer,
5550    {
5551        use serde::ser::SerializeStruct;
5552        let mut len = 0;
5553        if self.time_col != 0 {
5554            len += 1;
5555        }
5556        if self.window_slide.is_some() {
5557            len += 1;
5558        }
5559        if self.window_size.is_some() {
5560            len += 1;
5561        }
5562        if !self.output_indices.is_empty() {
5563            len += 1;
5564        }
5565        if !self.window_start_exprs.is_empty() {
5566            len += 1;
5567        }
5568        if !self.window_end_exprs.is_empty() {
5569            len += 1;
5570        }
5571        let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
5572        if self.time_col != 0 {
5573            struct_ser.serialize_field("timeCol", &self.time_col)?;
5574        }
5575        if let Some(v) = self.window_slide.as_ref() {
5576            struct_ser.serialize_field("windowSlide", v)?;
5577        }
5578        if let Some(v) = self.window_size.as_ref() {
5579            struct_ser.serialize_field("windowSize", v)?;
5580        }
5581        if !self.output_indices.is_empty() {
5582            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5583        }
5584        if !self.window_start_exprs.is_empty() {
5585            struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
5586        }
5587        if !self.window_end_exprs.is_empty() {
5588            struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
5589        }
5590        struct_ser.end()
5591    }
5592}
5593impl<'de> serde::Deserialize<'de> for HopWindowNode {
5594    #[allow(deprecated)]
5595    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5596    where
5597        D: serde::Deserializer<'de>,
5598    {
5599        const FIELDS: &[&str] = &[
5600            "time_col",
5601            "timeCol",
5602            "window_slide",
5603            "windowSlide",
5604            "window_size",
5605            "windowSize",
5606            "output_indices",
5607            "outputIndices",
5608            "window_start_exprs",
5609            "windowStartExprs",
5610            "window_end_exprs",
5611            "windowEndExprs",
5612        ];
5613
5614        #[allow(clippy::enum_variant_names)]
5615        enum GeneratedField {
5616            TimeCol,
5617            WindowSlide,
5618            WindowSize,
5619            OutputIndices,
5620            WindowStartExprs,
5621            WindowEndExprs,
5622        }
5623        impl<'de> serde::Deserialize<'de> for GeneratedField {
5624            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5625            where
5626                D: serde::Deserializer<'de>,
5627            {
5628                struct GeneratedVisitor;
5629
5630                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5631                    type Value = GeneratedField;
5632
5633                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5634                        write!(formatter, "expected one of: {:?}", &FIELDS)
5635                    }
5636
5637                    #[allow(unused_variables)]
5638                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5639                    where
5640                        E: serde::de::Error,
5641                    {
5642                        match value {
5643                            "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
5644                            "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
5645                            "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
5646                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5647                            "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
5648                            "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
5649                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5650                        }
5651                    }
5652                }
5653                deserializer.deserialize_identifier(GeneratedVisitor)
5654            }
5655        }
5656        struct GeneratedVisitor;
5657        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5658            type Value = HopWindowNode;
5659
5660            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5661                formatter.write_str("struct stream_plan.HopWindowNode")
5662            }
5663
5664            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
5665                where
5666                    V: serde::de::MapAccess<'de>,
5667            {
5668                let mut time_col__ = None;
5669                let mut window_slide__ = None;
5670                let mut window_size__ = None;
5671                let mut output_indices__ = None;
5672                let mut window_start_exprs__ = None;
5673                let mut window_end_exprs__ = None;
5674                while let Some(k) = map_.next_key()? {
5675                    match k {
5676                        GeneratedField::TimeCol => {
5677                            if time_col__.is_some() {
5678                                return Err(serde::de::Error::duplicate_field("timeCol"));
5679                            }
5680                            time_col__ = 
5681                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5682                            ;
5683                        }
5684                        GeneratedField::WindowSlide => {
5685                            if window_slide__.is_some() {
5686                                return Err(serde::de::Error::duplicate_field("windowSlide"));
5687                            }
5688                            window_slide__ = map_.next_value()?;
5689                        }
5690                        GeneratedField::WindowSize => {
5691                            if window_size__.is_some() {
5692                                return Err(serde::de::Error::duplicate_field("windowSize"));
5693                            }
5694                            window_size__ = map_.next_value()?;
5695                        }
5696                        GeneratedField::OutputIndices => {
5697                            if output_indices__.is_some() {
5698                                return Err(serde::de::Error::duplicate_field("outputIndices"));
5699                            }
5700                            output_indices__ = 
5701                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5702                                    .into_iter().map(|x| x.0).collect())
5703                            ;
5704                        }
5705                        GeneratedField::WindowStartExprs => {
5706                            if window_start_exprs__.is_some() {
5707                                return Err(serde::de::Error::duplicate_field("windowStartExprs"));
5708                            }
5709                            window_start_exprs__ = Some(map_.next_value()?);
5710                        }
5711                        GeneratedField::WindowEndExprs => {
5712                            if window_end_exprs__.is_some() {
5713                                return Err(serde::de::Error::duplicate_field("windowEndExprs"));
5714                            }
5715                            window_end_exprs__ = Some(map_.next_value()?);
5716                        }
5717                    }
5718                }
5719                Ok(HopWindowNode {
5720                    time_col: time_col__.unwrap_or_default(),
5721                    window_slide: window_slide__,
5722                    window_size: window_size__,
5723                    output_indices: output_indices__.unwrap_or_default(),
5724                    window_start_exprs: window_start_exprs__.unwrap_or_default(),
5725                    window_end_exprs: window_end_exprs__.unwrap_or_default(),
5726                })
5727            }
5728        }
5729        deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
5730    }
5731}
5732impl serde::Serialize for InequalityPair {
5733    #[allow(deprecated)]
5734    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5735    where
5736        S: serde::Serializer,
5737    {
5738        use serde::ser::SerializeStruct;
5739        let mut len = 0;
5740        if self.key_required_larger != 0 {
5741            len += 1;
5742        }
5743        if self.key_required_smaller != 0 {
5744            len += 1;
5745        }
5746        if self.clean_state {
5747            len += 1;
5748        }
5749        if self.delta_expression.is_some() {
5750            len += 1;
5751        }
5752        let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
5753        if self.key_required_larger != 0 {
5754            struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
5755        }
5756        if self.key_required_smaller != 0 {
5757            struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
5758        }
5759        if self.clean_state {
5760            struct_ser.serialize_field("cleanState", &self.clean_state)?;
5761        }
5762        if let Some(v) = self.delta_expression.as_ref() {
5763            struct_ser.serialize_field("deltaExpression", v)?;
5764        }
5765        struct_ser.end()
5766    }
5767}
5768impl<'de> serde::Deserialize<'de> for InequalityPair {
5769    #[allow(deprecated)]
5770    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5771    where
5772        D: serde::Deserializer<'de>,
5773    {
5774        const FIELDS: &[&str] = &[
5775            "key_required_larger",
5776            "keyRequiredLarger",
5777            "key_required_smaller",
5778            "keyRequiredSmaller",
5779            "clean_state",
5780            "cleanState",
5781            "delta_expression",
5782            "deltaExpression",
5783        ];
5784
5785        #[allow(clippy::enum_variant_names)]
5786        enum GeneratedField {
5787            KeyRequiredLarger,
5788            KeyRequiredSmaller,
5789            CleanState,
5790            DeltaExpression,
5791        }
5792        impl<'de> serde::Deserialize<'de> for GeneratedField {
5793            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5794            where
5795                D: serde::Deserializer<'de>,
5796            {
5797                struct GeneratedVisitor;
5798
5799                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5800                    type Value = GeneratedField;
5801
5802                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5803                        write!(formatter, "expected one of: {:?}", &FIELDS)
5804                    }
5805
5806                    #[allow(unused_variables)]
5807                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5808                    where
5809                        E: serde::de::Error,
5810                    {
5811                        match value {
5812                            "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
5813                            "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
5814                            "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
5815                            "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
5816                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5817                        }
5818                    }
5819                }
5820                deserializer.deserialize_identifier(GeneratedVisitor)
5821            }
5822        }
5823        struct GeneratedVisitor;
5824        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5825            type Value = InequalityPair;
5826
5827            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5828                formatter.write_str("struct stream_plan.InequalityPair")
5829            }
5830
5831            fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
5832                where
5833                    V: serde::de::MapAccess<'de>,
5834            {
5835                let mut key_required_larger__ = None;
5836                let mut key_required_smaller__ = None;
5837                let mut clean_state__ = None;
5838                let mut delta_expression__ = None;
5839                while let Some(k) = map_.next_key()? {
5840                    match k {
5841                        GeneratedField::KeyRequiredLarger => {
5842                            if key_required_larger__.is_some() {
5843                                return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
5844                            }
5845                            key_required_larger__ = 
5846                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5847                            ;
5848                        }
5849                        GeneratedField::KeyRequiredSmaller => {
5850                            if key_required_smaller__.is_some() {
5851                                return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
5852                            }
5853                            key_required_smaller__ = 
5854                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5855                            ;
5856                        }
5857                        GeneratedField::CleanState => {
5858                            if clean_state__.is_some() {
5859                                return Err(serde::de::Error::duplicate_field("cleanState"));
5860                            }
5861                            clean_state__ = Some(map_.next_value()?);
5862                        }
5863                        GeneratedField::DeltaExpression => {
5864                            if delta_expression__.is_some() {
5865                                return Err(serde::de::Error::duplicate_field("deltaExpression"));
5866                            }
5867                            delta_expression__ = map_.next_value()?;
5868                        }
5869                    }
5870                }
5871                Ok(InequalityPair {
5872                    key_required_larger: key_required_larger__.unwrap_or_default(),
5873                    key_required_smaller: key_required_smaller__.unwrap_or_default(),
5874                    clean_state: clean_state__.unwrap_or_default(),
5875                    delta_expression: delta_expression__,
5876                })
5877            }
5878        }
5879        deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
5880    }
5881}
5882impl serde::Serialize for LocalApproxPercentileNode {
5883    #[allow(deprecated)]
5884    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5885    where
5886        S: serde::Serializer,
5887    {
5888        use serde::ser::SerializeStruct;
5889        let mut len = 0;
5890        if self.base != 0. {
5891            len += 1;
5892        }
5893        if self.percentile_index != 0 {
5894            len += 1;
5895        }
5896        let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
5897        if self.base != 0. {
5898            struct_ser.serialize_field("base", &self.base)?;
5899        }
5900        if self.percentile_index != 0 {
5901            struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
5902        }
5903        struct_ser.end()
5904    }
5905}
5906impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
5907    #[allow(deprecated)]
5908    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5909    where
5910        D: serde::Deserializer<'de>,
5911    {
5912        const FIELDS: &[&str] = &[
5913            "base",
5914            "percentile_index",
5915            "percentileIndex",
5916        ];
5917
5918        #[allow(clippy::enum_variant_names)]
5919        enum GeneratedField {
5920            Base,
5921            PercentileIndex,
5922        }
5923        impl<'de> serde::Deserialize<'de> for GeneratedField {
5924            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5925            where
5926                D: serde::Deserializer<'de>,
5927            {
5928                struct GeneratedVisitor;
5929
5930                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5931                    type Value = GeneratedField;
5932
5933                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5934                        write!(formatter, "expected one of: {:?}", &FIELDS)
5935                    }
5936
5937                    #[allow(unused_variables)]
5938                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5939                    where
5940                        E: serde::de::Error,
5941                    {
5942                        match value {
5943                            "base" => Ok(GeneratedField::Base),
5944                            "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
5945                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5946                        }
5947                    }
5948                }
5949                deserializer.deserialize_identifier(GeneratedVisitor)
5950            }
5951        }
5952        struct GeneratedVisitor;
5953        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5954            type Value = LocalApproxPercentileNode;
5955
5956            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5957                formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
5958            }
5959
5960            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
5961                where
5962                    V: serde::de::MapAccess<'de>,
5963            {
5964                let mut base__ = None;
5965                let mut percentile_index__ = None;
5966                while let Some(k) = map_.next_key()? {
5967                    match k {
5968                        GeneratedField::Base => {
5969                            if base__.is_some() {
5970                                return Err(serde::de::Error::duplicate_field("base"));
5971                            }
5972                            base__ = 
5973                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5974                            ;
5975                        }
5976                        GeneratedField::PercentileIndex => {
5977                            if percentile_index__.is_some() {
5978                                return Err(serde::de::Error::duplicate_field("percentileIndex"));
5979                            }
5980                            percentile_index__ = 
5981                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5982                            ;
5983                        }
5984                    }
5985                }
5986                Ok(LocalApproxPercentileNode {
5987                    base: base__.unwrap_or_default(),
5988                    percentile_index: percentile_index__.unwrap_or_default(),
5989                })
5990            }
5991        }
5992        deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
5993    }
5994}
5995impl serde::Serialize for LookupNode {
5996    #[allow(deprecated)]
5997    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5998    where
5999        S: serde::Serializer,
6000    {
6001        use serde::ser::SerializeStruct;
6002        let mut len = 0;
6003        if !self.arrange_key.is_empty() {
6004            len += 1;
6005        }
6006        if !self.stream_key.is_empty() {
6007            len += 1;
6008        }
6009        if self.use_current_epoch {
6010            len += 1;
6011        }
6012        if !self.column_mapping.is_empty() {
6013            len += 1;
6014        }
6015        if self.arrangement_table_info.is_some() {
6016            len += 1;
6017        }
6018        if self.arrangement_table_id.is_some() {
6019            len += 1;
6020        }
6021        let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
6022        if !self.arrange_key.is_empty() {
6023            struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
6024        }
6025        if !self.stream_key.is_empty() {
6026            struct_ser.serialize_field("streamKey", &self.stream_key)?;
6027        }
6028        if self.use_current_epoch {
6029            struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
6030        }
6031        if !self.column_mapping.is_empty() {
6032            struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
6033        }
6034        if let Some(v) = self.arrangement_table_info.as_ref() {
6035            struct_ser.serialize_field("arrangementTableInfo", v)?;
6036        }
6037        if let Some(v) = self.arrangement_table_id.as_ref() {
6038            match v {
6039                lookup_node::ArrangementTableId::TableId(v) => {
6040                    struct_ser.serialize_field("tableId", v)?;
6041                }
6042                lookup_node::ArrangementTableId::IndexId(v) => {
6043                    struct_ser.serialize_field("indexId", v)?;
6044                }
6045            }
6046        }
6047        struct_ser.end()
6048    }
6049}
6050impl<'de> serde::Deserialize<'de> for LookupNode {
6051    #[allow(deprecated)]
6052    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6053    where
6054        D: serde::Deserializer<'de>,
6055    {
6056        const FIELDS: &[&str] = &[
6057            "arrange_key",
6058            "arrangeKey",
6059            "stream_key",
6060            "streamKey",
6061            "use_current_epoch",
6062            "useCurrentEpoch",
6063            "column_mapping",
6064            "columnMapping",
6065            "arrangement_table_info",
6066            "arrangementTableInfo",
6067            "table_id",
6068            "tableId",
6069            "index_id",
6070            "indexId",
6071        ];
6072
6073        #[allow(clippy::enum_variant_names)]
6074        enum GeneratedField {
6075            ArrangeKey,
6076            StreamKey,
6077            UseCurrentEpoch,
6078            ColumnMapping,
6079            ArrangementTableInfo,
6080            TableId,
6081            IndexId,
6082        }
6083        impl<'de> serde::Deserialize<'de> for GeneratedField {
6084            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6085            where
6086                D: serde::Deserializer<'de>,
6087            {
6088                struct GeneratedVisitor;
6089
6090                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6091                    type Value = GeneratedField;
6092
6093                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6094                        write!(formatter, "expected one of: {:?}", &FIELDS)
6095                    }
6096
6097                    #[allow(unused_variables)]
6098                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6099                    where
6100                        E: serde::de::Error,
6101                    {
6102                        match value {
6103                            "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
6104                            "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
6105                            "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
6106                            "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
6107                            "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
6108                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
6109                            "indexId" | "index_id" => Ok(GeneratedField::IndexId),
6110                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6111                        }
6112                    }
6113                }
6114                deserializer.deserialize_identifier(GeneratedVisitor)
6115            }
6116        }
6117        struct GeneratedVisitor;
6118        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6119            type Value = LookupNode;
6120
6121            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6122                formatter.write_str("struct stream_plan.LookupNode")
6123            }
6124
6125            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
6126                where
6127                    V: serde::de::MapAccess<'de>,
6128            {
6129                let mut arrange_key__ = None;
6130                let mut stream_key__ = None;
6131                let mut use_current_epoch__ = None;
6132                let mut column_mapping__ = None;
6133                let mut arrangement_table_info__ = None;
6134                let mut arrangement_table_id__ = None;
6135                while let Some(k) = map_.next_key()? {
6136                    match k {
6137                        GeneratedField::ArrangeKey => {
6138                            if arrange_key__.is_some() {
6139                                return Err(serde::de::Error::duplicate_field("arrangeKey"));
6140                            }
6141                            arrange_key__ = 
6142                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6143                                    .into_iter().map(|x| x.0).collect())
6144                            ;
6145                        }
6146                        GeneratedField::StreamKey => {
6147                            if stream_key__.is_some() {
6148                                return Err(serde::de::Error::duplicate_field("streamKey"));
6149                            }
6150                            stream_key__ = 
6151                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6152                                    .into_iter().map(|x| x.0).collect())
6153                            ;
6154                        }
6155                        GeneratedField::UseCurrentEpoch => {
6156                            if use_current_epoch__.is_some() {
6157                                return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
6158                            }
6159                            use_current_epoch__ = Some(map_.next_value()?);
6160                        }
6161                        GeneratedField::ColumnMapping => {
6162                            if column_mapping__.is_some() {
6163                                return Err(serde::de::Error::duplicate_field("columnMapping"));
6164                            }
6165                            column_mapping__ = 
6166                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6167                                    .into_iter().map(|x| x.0).collect())
6168                            ;
6169                        }
6170                        GeneratedField::ArrangementTableInfo => {
6171                            if arrangement_table_info__.is_some() {
6172                                return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
6173                            }
6174                            arrangement_table_info__ = map_.next_value()?;
6175                        }
6176                        GeneratedField::TableId => {
6177                            if arrangement_table_id__.is_some() {
6178                                return Err(serde::de::Error::duplicate_field("tableId"));
6179                            }
6180                            arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
6181                        }
6182                        GeneratedField::IndexId => {
6183                            if arrangement_table_id__.is_some() {
6184                                return Err(serde::de::Error::duplicate_field("indexId"));
6185                            }
6186                            arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
6187                        }
6188                    }
6189                }
6190                Ok(LookupNode {
6191                    arrange_key: arrange_key__.unwrap_or_default(),
6192                    stream_key: stream_key__.unwrap_or_default(),
6193                    use_current_epoch: use_current_epoch__.unwrap_or_default(),
6194                    column_mapping: column_mapping__.unwrap_or_default(),
6195                    arrangement_table_info: arrangement_table_info__,
6196                    arrangement_table_id: arrangement_table_id__,
6197                })
6198            }
6199        }
6200        deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
6201    }
6202}
6203impl serde::Serialize for LookupUnionNode {
6204    #[allow(deprecated)]
6205    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6206    where
6207        S: serde::Serializer,
6208    {
6209        use serde::ser::SerializeStruct;
6210        let mut len = 0;
6211        if !self.order.is_empty() {
6212            len += 1;
6213        }
6214        let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
6215        if !self.order.is_empty() {
6216            struct_ser.serialize_field("order", &self.order)?;
6217        }
6218        struct_ser.end()
6219    }
6220}
6221impl<'de> serde::Deserialize<'de> for LookupUnionNode {
6222    #[allow(deprecated)]
6223    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6224    where
6225        D: serde::Deserializer<'de>,
6226    {
6227        const FIELDS: &[&str] = &[
6228            "order",
6229        ];
6230
6231        #[allow(clippy::enum_variant_names)]
6232        enum GeneratedField {
6233            Order,
6234        }
6235        impl<'de> serde::Deserialize<'de> for GeneratedField {
6236            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6237            where
6238                D: serde::Deserializer<'de>,
6239            {
6240                struct GeneratedVisitor;
6241
6242                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6243                    type Value = GeneratedField;
6244
6245                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6246                        write!(formatter, "expected one of: {:?}", &FIELDS)
6247                    }
6248
6249                    #[allow(unused_variables)]
6250                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6251                    where
6252                        E: serde::de::Error,
6253                    {
6254                        match value {
6255                            "order" => Ok(GeneratedField::Order),
6256                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6257                        }
6258                    }
6259                }
6260                deserializer.deserialize_identifier(GeneratedVisitor)
6261            }
6262        }
6263        struct GeneratedVisitor;
6264        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6265            type Value = LookupUnionNode;
6266
6267            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6268                formatter.write_str("struct stream_plan.LookupUnionNode")
6269            }
6270
6271            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
6272                where
6273                    V: serde::de::MapAccess<'de>,
6274            {
6275                let mut order__ = None;
6276                while let Some(k) = map_.next_key()? {
6277                    match k {
6278                        GeneratedField::Order => {
6279                            if order__.is_some() {
6280                                return Err(serde::de::Error::duplicate_field("order"));
6281                            }
6282                            order__ = 
6283                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6284                                    .into_iter().map(|x| x.0).collect())
6285                            ;
6286                        }
6287                    }
6288                }
6289                Ok(LookupUnionNode {
6290                    order: order__.unwrap_or_default(),
6291                })
6292            }
6293        }
6294        deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
6295    }
6296}
6297impl serde::Serialize for MaterializeNode {
6298    #[allow(deprecated)]
6299    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6300    where
6301        S: serde::Serializer,
6302    {
6303        use serde::ser::SerializeStruct;
6304        let mut len = 0;
6305        if self.table_id != 0 {
6306            len += 1;
6307        }
6308        if !self.column_orders.is_empty() {
6309            len += 1;
6310        }
6311        if self.table.is_some() {
6312            len += 1;
6313        }
6314        let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
6315        if self.table_id != 0 {
6316            struct_ser.serialize_field("tableId", &self.table_id)?;
6317        }
6318        if !self.column_orders.is_empty() {
6319            struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6320        }
6321        if let Some(v) = self.table.as_ref() {
6322            struct_ser.serialize_field("table", v)?;
6323        }
6324        struct_ser.end()
6325    }
6326}
6327impl<'de> serde::Deserialize<'de> for MaterializeNode {
6328    #[allow(deprecated)]
6329    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6330    where
6331        D: serde::Deserializer<'de>,
6332    {
6333        const FIELDS: &[&str] = &[
6334            "table_id",
6335            "tableId",
6336            "column_orders",
6337            "columnOrders",
6338            "table",
6339        ];
6340
6341        #[allow(clippy::enum_variant_names)]
6342        enum GeneratedField {
6343            TableId,
6344            ColumnOrders,
6345            Table,
6346        }
6347        impl<'de> serde::Deserialize<'de> for GeneratedField {
6348            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6349            where
6350                D: serde::Deserializer<'de>,
6351            {
6352                struct GeneratedVisitor;
6353
6354                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6355                    type Value = GeneratedField;
6356
6357                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6358                        write!(formatter, "expected one of: {:?}", &FIELDS)
6359                    }
6360
6361                    #[allow(unused_variables)]
6362                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6363                    where
6364                        E: serde::de::Error,
6365                    {
6366                        match value {
6367                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
6368                            "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6369                            "table" => Ok(GeneratedField::Table),
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 = MaterializeNode;
6380
6381            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6382                formatter.write_str("struct stream_plan.MaterializeNode")
6383            }
6384
6385            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
6386                where
6387                    V: serde::de::MapAccess<'de>,
6388            {
6389                let mut table_id__ = None;
6390                let mut column_orders__ = None;
6391                let mut table__ = None;
6392                while let Some(k) = map_.next_key()? {
6393                    match k {
6394                        GeneratedField::TableId => {
6395                            if table_id__.is_some() {
6396                                return Err(serde::de::Error::duplicate_field("tableId"));
6397                            }
6398                            table_id__ = 
6399                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6400                            ;
6401                        }
6402                        GeneratedField::ColumnOrders => {
6403                            if column_orders__.is_some() {
6404                                return Err(serde::de::Error::duplicate_field("columnOrders"));
6405                            }
6406                            column_orders__ = Some(map_.next_value()?);
6407                        }
6408                        GeneratedField::Table => {
6409                            if table__.is_some() {
6410                                return Err(serde::de::Error::duplicate_field("table"));
6411                            }
6412                            table__ = map_.next_value()?;
6413                        }
6414                    }
6415                }
6416                Ok(MaterializeNode {
6417                    table_id: table_id__.unwrap_or_default(),
6418                    column_orders: column_orders__.unwrap_or_default(),
6419                    table: table__,
6420                })
6421            }
6422        }
6423        deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
6424    }
6425}
6426impl serde::Serialize for MaterializedExprsNode {
6427    #[allow(deprecated)]
6428    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6429    where
6430        S: serde::Serializer,
6431    {
6432        use serde::ser::SerializeStruct;
6433        let mut len = 0;
6434        if !self.exprs.is_empty() {
6435            len += 1;
6436        }
6437        if self.state_table.is_some() {
6438            len += 1;
6439        }
6440        if self.state_clean_col_idx.is_some() {
6441            len += 1;
6442        }
6443        let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
6444        if !self.exprs.is_empty() {
6445            struct_ser.serialize_field("exprs", &self.exprs)?;
6446        }
6447        if let Some(v) = self.state_table.as_ref() {
6448            struct_ser.serialize_field("stateTable", v)?;
6449        }
6450        if let Some(v) = self.state_clean_col_idx.as_ref() {
6451            struct_ser.serialize_field("stateCleanColIdx", v)?;
6452        }
6453        struct_ser.end()
6454    }
6455}
6456impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
6457    #[allow(deprecated)]
6458    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6459    where
6460        D: serde::Deserializer<'de>,
6461    {
6462        const FIELDS: &[&str] = &[
6463            "exprs",
6464            "state_table",
6465            "stateTable",
6466            "state_clean_col_idx",
6467            "stateCleanColIdx",
6468        ];
6469
6470        #[allow(clippy::enum_variant_names)]
6471        enum GeneratedField {
6472            Exprs,
6473            StateTable,
6474            StateCleanColIdx,
6475        }
6476        impl<'de> serde::Deserialize<'de> for GeneratedField {
6477            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6478            where
6479                D: serde::Deserializer<'de>,
6480            {
6481                struct GeneratedVisitor;
6482
6483                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6484                    type Value = GeneratedField;
6485
6486                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6487                        write!(formatter, "expected one of: {:?}", &FIELDS)
6488                    }
6489
6490                    #[allow(unused_variables)]
6491                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6492                    where
6493                        E: serde::de::Error,
6494                    {
6495                        match value {
6496                            "exprs" => Ok(GeneratedField::Exprs),
6497                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
6498                            "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
6499                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6500                        }
6501                    }
6502                }
6503                deserializer.deserialize_identifier(GeneratedVisitor)
6504            }
6505        }
6506        struct GeneratedVisitor;
6507        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6508            type Value = MaterializedExprsNode;
6509
6510            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6511                formatter.write_str("struct stream_plan.MaterializedExprsNode")
6512            }
6513
6514            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
6515                where
6516                    V: serde::de::MapAccess<'de>,
6517            {
6518                let mut exprs__ = None;
6519                let mut state_table__ = None;
6520                let mut state_clean_col_idx__ = None;
6521                while let Some(k) = map_.next_key()? {
6522                    match k {
6523                        GeneratedField::Exprs => {
6524                            if exprs__.is_some() {
6525                                return Err(serde::de::Error::duplicate_field("exprs"));
6526                            }
6527                            exprs__ = Some(map_.next_value()?);
6528                        }
6529                        GeneratedField::StateTable => {
6530                            if state_table__.is_some() {
6531                                return Err(serde::de::Error::duplicate_field("stateTable"));
6532                            }
6533                            state_table__ = map_.next_value()?;
6534                        }
6535                        GeneratedField::StateCleanColIdx => {
6536                            if state_clean_col_idx__.is_some() {
6537                                return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
6538                            }
6539                            state_clean_col_idx__ = 
6540                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6541                            ;
6542                        }
6543                    }
6544                }
6545                Ok(MaterializedExprsNode {
6546                    exprs: exprs__.unwrap_or_default(),
6547                    state_table: state_table__,
6548                    state_clean_col_idx: state_clean_col_idx__,
6549                })
6550            }
6551        }
6552        deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
6553    }
6554}
6555impl serde::Serialize for MergeNode {
6556    #[allow(deprecated)]
6557    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6558    where
6559        S: serde::Serializer,
6560    {
6561        use serde::ser::SerializeStruct;
6562        let mut len = 0;
6563        if !self.upstream_actor_id.is_empty() {
6564            len += 1;
6565        }
6566        if self.upstream_fragment_id != 0 {
6567            len += 1;
6568        }
6569        if self.upstream_dispatcher_type != 0 {
6570            len += 1;
6571        }
6572        if !self.fields.is_empty() {
6573            len += 1;
6574        }
6575        let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
6576        if !self.upstream_actor_id.is_empty() {
6577            struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
6578        }
6579        if self.upstream_fragment_id != 0 {
6580            struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
6581        }
6582        if self.upstream_dispatcher_type != 0 {
6583            let v = DispatcherType::try_from(self.upstream_dispatcher_type)
6584                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
6585            struct_ser.serialize_field("upstreamDispatcherType", &v)?;
6586        }
6587        if !self.fields.is_empty() {
6588            struct_ser.serialize_field("fields", &self.fields)?;
6589        }
6590        struct_ser.end()
6591    }
6592}
6593impl<'de> serde::Deserialize<'de> for MergeNode {
6594    #[allow(deprecated)]
6595    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6596    where
6597        D: serde::Deserializer<'de>,
6598    {
6599        const FIELDS: &[&str] = &[
6600            "upstream_actor_id",
6601            "upstreamActorId",
6602            "upstream_fragment_id",
6603            "upstreamFragmentId",
6604            "upstream_dispatcher_type",
6605            "upstreamDispatcherType",
6606            "fields",
6607        ];
6608
6609        #[allow(clippy::enum_variant_names)]
6610        enum GeneratedField {
6611            UpstreamActorId,
6612            UpstreamFragmentId,
6613            UpstreamDispatcherType,
6614            Fields,
6615        }
6616        impl<'de> serde::Deserialize<'de> for GeneratedField {
6617            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6618            where
6619                D: serde::Deserializer<'de>,
6620            {
6621                struct GeneratedVisitor;
6622
6623                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6624                    type Value = GeneratedField;
6625
6626                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6627                        write!(formatter, "expected one of: {:?}", &FIELDS)
6628                    }
6629
6630                    #[allow(unused_variables)]
6631                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6632                    where
6633                        E: serde::de::Error,
6634                    {
6635                        match value {
6636                            "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
6637                            "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
6638                            "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
6639                            "fields" => Ok(GeneratedField::Fields),
6640                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6641                        }
6642                    }
6643                }
6644                deserializer.deserialize_identifier(GeneratedVisitor)
6645            }
6646        }
6647        struct GeneratedVisitor;
6648        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6649            type Value = MergeNode;
6650
6651            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6652                formatter.write_str("struct stream_plan.MergeNode")
6653            }
6654
6655            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
6656                where
6657                    V: serde::de::MapAccess<'de>,
6658            {
6659                let mut upstream_actor_id__ = None;
6660                let mut upstream_fragment_id__ = None;
6661                let mut upstream_dispatcher_type__ = None;
6662                let mut fields__ = None;
6663                while let Some(k) = map_.next_key()? {
6664                    match k {
6665                        GeneratedField::UpstreamActorId => {
6666                            if upstream_actor_id__.is_some() {
6667                                return Err(serde::de::Error::duplicate_field("upstreamActorId"));
6668                            }
6669                            upstream_actor_id__ = 
6670                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6671                                    .into_iter().map(|x| x.0).collect())
6672                            ;
6673                        }
6674                        GeneratedField::UpstreamFragmentId => {
6675                            if upstream_fragment_id__.is_some() {
6676                                return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
6677                            }
6678                            upstream_fragment_id__ = 
6679                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6680                            ;
6681                        }
6682                        GeneratedField::UpstreamDispatcherType => {
6683                            if upstream_dispatcher_type__.is_some() {
6684                                return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
6685                            }
6686                            upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
6687                        }
6688                        GeneratedField::Fields => {
6689                            if fields__.is_some() {
6690                                return Err(serde::de::Error::duplicate_field("fields"));
6691                            }
6692                            fields__ = Some(map_.next_value()?);
6693                        }
6694                    }
6695                }
6696                Ok(MergeNode {
6697                    upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
6698                    upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
6699                    upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
6700                    fields: fields__.unwrap_or_default(),
6701                })
6702            }
6703        }
6704        deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
6705    }
6706}
6707impl serde::Serialize for NoOpNode {
6708    #[allow(deprecated)]
6709    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6710    where
6711        S: serde::Serializer,
6712    {
6713        use serde::ser::SerializeStruct;
6714        let len = 0;
6715        let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
6716        struct_ser.end()
6717    }
6718}
6719impl<'de> serde::Deserialize<'de> for NoOpNode {
6720    #[allow(deprecated)]
6721    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6722    where
6723        D: serde::Deserializer<'de>,
6724    {
6725        const FIELDS: &[&str] = &[
6726        ];
6727
6728        #[allow(clippy::enum_variant_names)]
6729        enum GeneratedField {
6730        }
6731        impl<'de> serde::Deserialize<'de> for GeneratedField {
6732            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6733            where
6734                D: serde::Deserializer<'de>,
6735            {
6736                struct GeneratedVisitor;
6737
6738                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6739                    type Value = GeneratedField;
6740
6741                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6742                        write!(formatter, "expected one of: {:?}", &FIELDS)
6743                    }
6744
6745                    #[allow(unused_variables)]
6746                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6747                    where
6748                        E: serde::de::Error,
6749                    {
6750                            Err(serde::de::Error::unknown_field(value, FIELDS))
6751                    }
6752                }
6753                deserializer.deserialize_identifier(GeneratedVisitor)
6754            }
6755        }
6756        struct GeneratedVisitor;
6757        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6758            type Value = NoOpNode;
6759
6760            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6761                formatter.write_str("struct stream_plan.NoOpNode")
6762            }
6763
6764            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
6765                where
6766                    V: serde::de::MapAccess<'de>,
6767            {
6768                while map_.next_key::<GeneratedField>()?.is_some() {
6769                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6770                }
6771                Ok(NoOpNode {
6772                })
6773            }
6774        }
6775        deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
6776    }
6777}
6778impl serde::Serialize for NowModeGenerateSeries {
6779    #[allow(deprecated)]
6780    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6781    where
6782        S: serde::Serializer,
6783    {
6784        use serde::ser::SerializeStruct;
6785        let mut len = 0;
6786        if self.start_timestamp.is_some() {
6787            len += 1;
6788        }
6789        if self.interval.is_some() {
6790            len += 1;
6791        }
6792        let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
6793        if let Some(v) = self.start_timestamp.as_ref() {
6794            struct_ser.serialize_field("startTimestamp", v)?;
6795        }
6796        if let Some(v) = self.interval.as_ref() {
6797            struct_ser.serialize_field("interval", v)?;
6798        }
6799        struct_ser.end()
6800    }
6801}
6802impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
6803    #[allow(deprecated)]
6804    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6805    where
6806        D: serde::Deserializer<'de>,
6807    {
6808        const FIELDS: &[&str] = &[
6809            "start_timestamp",
6810            "startTimestamp",
6811            "interval",
6812        ];
6813
6814        #[allow(clippy::enum_variant_names)]
6815        enum GeneratedField {
6816            StartTimestamp,
6817            Interval,
6818        }
6819        impl<'de> serde::Deserialize<'de> for GeneratedField {
6820            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6821            where
6822                D: serde::Deserializer<'de>,
6823            {
6824                struct GeneratedVisitor;
6825
6826                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6827                    type Value = GeneratedField;
6828
6829                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6830                        write!(formatter, "expected one of: {:?}", &FIELDS)
6831                    }
6832
6833                    #[allow(unused_variables)]
6834                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6835                    where
6836                        E: serde::de::Error,
6837                    {
6838                        match value {
6839                            "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
6840                            "interval" => Ok(GeneratedField::Interval),
6841                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6842                        }
6843                    }
6844                }
6845                deserializer.deserialize_identifier(GeneratedVisitor)
6846            }
6847        }
6848        struct GeneratedVisitor;
6849        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6850            type Value = NowModeGenerateSeries;
6851
6852            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6853                formatter.write_str("struct stream_plan.NowModeGenerateSeries")
6854            }
6855
6856            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
6857                where
6858                    V: serde::de::MapAccess<'de>,
6859            {
6860                let mut start_timestamp__ = None;
6861                let mut interval__ = None;
6862                while let Some(k) = map_.next_key()? {
6863                    match k {
6864                        GeneratedField::StartTimestamp => {
6865                            if start_timestamp__.is_some() {
6866                                return Err(serde::de::Error::duplicate_field("startTimestamp"));
6867                            }
6868                            start_timestamp__ = map_.next_value()?;
6869                        }
6870                        GeneratedField::Interval => {
6871                            if interval__.is_some() {
6872                                return Err(serde::de::Error::duplicate_field("interval"));
6873                            }
6874                            interval__ = map_.next_value()?;
6875                        }
6876                    }
6877                }
6878                Ok(NowModeGenerateSeries {
6879                    start_timestamp: start_timestamp__,
6880                    interval: interval__,
6881                })
6882            }
6883        }
6884        deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
6885    }
6886}
6887impl serde::Serialize for NowModeUpdateCurrent {
6888    #[allow(deprecated)]
6889    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6890    where
6891        S: serde::Serializer,
6892    {
6893        use serde::ser::SerializeStruct;
6894        let len = 0;
6895        let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
6896        struct_ser.end()
6897    }
6898}
6899impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
6900    #[allow(deprecated)]
6901    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6902    where
6903        D: serde::Deserializer<'de>,
6904    {
6905        const FIELDS: &[&str] = &[
6906        ];
6907
6908        #[allow(clippy::enum_variant_names)]
6909        enum GeneratedField {
6910        }
6911        impl<'de> serde::Deserialize<'de> for GeneratedField {
6912            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6913            where
6914                D: serde::Deserializer<'de>,
6915            {
6916                struct GeneratedVisitor;
6917
6918                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6919                    type Value = GeneratedField;
6920
6921                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6922                        write!(formatter, "expected one of: {:?}", &FIELDS)
6923                    }
6924
6925                    #[allow(unused_variables)]
6926                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6927                    where
6928                        E: serde::de::Error,
6929                    {
6930                            Err(serde::de::Error::unknown_field(value, FIELDS))
6931                    }
6932                }
6933                deserializer.deserialize_identifier(GeneratedVisitor)
6934            }
6935        }
6936        struct GeneratedVisitor;
6937        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6938            type Value = NowModeUpdateCurrent;
6939
6940            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6941                formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
6942            }
6943
6944            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
6945                where
6946                    V: serde::de::MapAccess<'de>,
6947            {
6948                while map_.next_key::<GeneratedField>()?.is_some() {
6949                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
6950                }
6951                Ok(NowModeUpdateCurrent {
6952                })
6953            }
6954        }
6955        deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
6956    }
6957}
6958impl serde::Serialize for NowNode {
6959    #[allow(deprecated)]
6960    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6961    where
6962        S: serde::Serializer,
6963    {
6964        use serde::ser::SerializeStruct;
6965        let mut len = 0;
6966        if self.state_table.is_some() {
6967            len += 1;
6968        }
6969        if self.mode.is_some() {
6970            len += 1;
6971        }
6972        let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
6973        if let Some(v) = self.state_table.as_ref() {
6974            struct_ser.serialize_field("stateTable", v)?;
6975        }
6976        if let Some(v) = self.mode.as_ref() {
6977            match v {
6978                now_node::Mode::UpdateCurrent(v) => {
6979                    struct_ser.serialize_field("updateCurrent", v)?;
6980                }
6981                now_node::Mode::GenerateSeries(v) => {
6982                    struct_ser.serialize_field("generateSeries", v)?;
6983                }
6984            }
6985        }
6986        struct_ser.end()
6987    }
6988}
6989impl<'de> serde::Deserialize<'de> for NowNode {
6990    #[allow(deprecated)]
6991    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6992    where
6993        D: serde::Deserializer<'de>,
6994    {
6995        const FIELDS: &[&str] = &[
6996            "state_table",
6997            "stateTable",
6998            "update_current",
6999            "updateCurrent",
7000            "generate_series",
7001            "generateSeries",
7002        ];
7003
7004        #[allow(clippy::enum_variant_names)]
7005        enum GeneratedField {
7006            StateTable,
7007            UpdateCurrent,
7008            GenerateSeries,
7009        }
7010        impl<'de> serde::Deserialize<'de> for GeneratedField {
7011            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7012            where
7013                D: serde::Deserializer<'de>,
7014            {
7015                struct GeneratedVisitor;
7016
7017                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7018                    type Value = GeneratedField;
7019
7020                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7021                        write!(formatter, "expected one of: {:?}", &FIELDS)
7022                    }
7023
7024                    #[allow(unused_variables)]
7025                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7026                    where
7027                        E: serde::de::Error,
7028                    {
7029                        match value {
7030                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7031                            "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
7032                            "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
7033                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7034                        }
7035                    }
7036                }
7037                deserializer.deserialize_identifier(GeneratedVisitor)
7038            }
7039        }
7040        struct GeneratedVisitor;
7041        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7042            type Value = NowNode;
7043
7044            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7045                formatter.write_str("struct stream_plan.NowNode")
7046            }
7047
7048            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
7049                where
7050                    V: serde::de::MapAccess<'de>,
7051            {
7052                let mut state_table__ = None;
7053                let mut mode__ = None;
7054                while let Some(k) = map_.next_key()? {
7055                    match k {
7056                        GeneratedField::StateTable => {
7057                            if state_table__.is_some() {
7058                                return Err(serde::de::Error::duplicate_field("stateTable"));
7059                            }
7060                            state_table__ = map_.next_value()?;
7061                        }
7062                        GeneratedField::UpdateCurrent => {
7063                            if mode__.is_some() {
7064                                return Err(serde::de::Error::duplicate_field("updateCurrent"));
7065                            }
7066                            mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
7067;
7068                        }
7069                        GeneratedField::GenerateSeries => {
7070                            if mode__.is_some() {
7071                                return Err(serde::de::Error::duplicate_field("generateSeries"));
7072                            }
7073                            mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
7074;
7075                        }
7076                    }
7077                }
7078                Ok(NowNode {
7079                    state_table: state_table__,
7080                    mode: mode__,
7081                })
7082            }
7083        }
7084        deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
7085    }
7086}
7087impl serde::Serialize for OverWindowCachePolicy {
7088    #[allow(deprecated)]
7089    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7090    where
7091        S: serde::Serializer,
7092    {
7093        let variant = match self {
7094            Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7095            Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
7096            Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
7097            Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7098            Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7099        };
7100        serializer.serialize_str(variant)
7101    }
7102}
7103impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
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            "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7111            "OVER_WINDOW_CACHE_POLICY_FULL",
7112            "OVER_WINDOW_CACHE_POLICY_RECENT",
7113            "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7114            "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7115        ];
7116
7117        struct GeneratedVisitor;
7118
7119        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7120            type Value = OverWindowCachePolicy;
7121
7122            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7123                write!(formatter, "expected one of: {:?}", &FIELDS)
7124            }
7125
7126            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7127            where
7128                E: serde::de::Error,
7129            {
7130                i32::try_from(v)
7131                    .ok()
7132                    .and_then(|x| x.try_into().ok())
7133                    .ok_or_else(|| {
7134                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7135                    })
7136            }
7137
7138            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7139            where
7140                E: serde::de::Error,
7141            {
7142                i32::try_from(v)
7143                    .ok()
7144                    .and_then(|x| x.try_into().ok())
7145                    .ok_or_else(|| {
7146                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7147                    })
7148            }
7149
7150            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7151            where
7152                E: serde::de::Error,
7153            {
7154                match value {
7155                    "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
7156                    "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
7157                    "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
7158                    "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
7159                    "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
7160                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7161                }
7162            }
7163        }
7164        deserializer.deserialize_any(GeneratedVisitor)
7165    }
7166}
7167impl serde::Serialize for OverWindowNode {
7168    #[allow(deprecated)]
7169    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7170    where
7171        S: serde::Serializer,
7172    {
7173        use serde::ser::SerializeStruct;
7174        let mut len = 0;
7175        if !self.calls.is_empty() {
7176            len += 1;
7177        }
7178        if !self.partition_by.is_empty() {
7179            len += 1;
7180        }
7181        if !self.order_by.is_empty() {
7182            len += 1;
7183        }
7184        if self.state_table.is_some() {
7185            len += 1;
7186        }
7187        if self.cache_policy != 0 {
7188            len += 1;
7189        }
7190        let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
7191        if !self.calls.is_empty() {
7192            struct_ser.serialize_field("calls", &self.calls)?;
7193        }
7194        if !self.partition_by.is_empty() {
7195            struct_ser.serialize_field("partitionBy", &self.partition_by)?;
7196        }
7197        if !self.order_by.is_empty() {
7198            struct_ser.serialize_field("orderBy", &self.order_by)?;
7199        }
7200        if let Some(v) = self.state_table.as_ref() {
7201            struct_ser.serialize_field("stateTable", v)?;
7202        }
7203        if self.cache_policy != 0 {
7204            let v = OverWindowCachePolicy::try_from(self.cache_policy)
7205                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
7206            struct_ser.serialize_field("cachePolicy", &v)?;
7207        }
7208        struct_ser.end()
7209    }
7210}
7211impl<'de> serde::Deserialize<'de> for OverWindowNode {
7212    #[allow(deprecated)]
7213    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7214    where
7215        D: serde::Deserializer<'de>,
7216    {
7217        const FIELDS: &[&str] = &[
7218            "calls",
7219            "partition_by",
7220            "partitionBy",
7221            "order_by",
7222            "orderBy",
7223            "state_table",
7224            "stateTable",
7225            "cache_policy",
7226            "cachePolicy",
7227        ];
7228
7229        #[allow(clippy::enum_variant_names)]
7230        enum GeneratedField {
7231            Calls,
7232            PartitionBy,
7233            OrderBy,
7234            StateTable,
7235            CachePolicy,
7236        }
7237        impl<'de> serde::Deserialize<'de> for GeneratedField {
7238            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7239            where
7240                D: serde::Deserializer<'de>,
7241            {
7242                struct GeneratedVisitor;
7243
7244                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7245                    type Value = GeneratedField;
7246
7247                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7248                        write!(formatter, "expected one of: {:?}", &FIELDS)
7249                    }
7250
7251                    #[allow(unused_variables)]
7252                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7253                    where
7254                        E: serde::de::Error,
7255                    {
7256                        match value {
7257                            "calls" => Ok(GeneratedField::Calls),
7258                            "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
7259                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
7260                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7261                            "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
7262                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7263                        }
7264                    }
7265                }
7266                deserializer.deserialize_identifier(GeneratedVisitor)
7267            }
7268        }
7269        struct GeneratedVisitor;
7270        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7271            type Value = OverWindowNode;
7272
7273            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7274                formatter.write_str("struct stream_plan.OverWindowNode")
7275            }
7276
7277            fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
7278                where
7279                    V: serde::de::MapAccess<'de>,
7280            {
7281                let mut calls__ = None;
7282                let mut partition_by__ = None;
7283                let mut order_by__ = None;
7284                let mut state_table__ = None;
7285                let mut cache_policy__ = None;
7286                while let Some(k) = map_.next_key()? {
7287                    match k {
7288                        GeneratedField::Calls => {
7289                            if calls__.is_some() {
7290                                return Err(serde::de::Error::duplicate_field("calls"));
7291                            }
7292                            calls__ = Some(map_.next_value()?);
7293                        }
7294                        GeneratedField::PartitionBy => {
7295                            if partition_by__.is_some() {
7296                                return Err(serde::de::Error::duplicate_field("partitionBy"));
7297                            }
7298                            partition_by__ = 
7299                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7300                                    .into_iter().map(|x| x.0).collect())
7301                            ;
7302                        }
7303                        GeneratedField::OrderBy => {
7304                            if order_by__.is_some() {
7305                                return Err(serde::de::Error::duplicate_field("orderBy"));
7306                            }
7307                            order_by__ = Some(map_.next_value()?);
7308                        }
7309                        GeneratedField::StateTable => {
7310                            if state_table__.is_some() {
7311                                return Err(serde::de::Error::duplicate_field("stateTable"));
7312                            }
7313                            state_table__ = map_.next_value()?;
7314                        }
7315                        GeneratedField::CachePolicy => {
7316                            if cache_policy__.is_some() {
7317                                return Err(serde::de::Error::duplicate_field("cachePolicy"));
7318                            }
7319                            cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
7320                        }
7321                    }
7322                }
7323                Ok(OverWindowNode {
7324                    calls: calls__.unwrap_or_default(),
7325                    partition_by: partition_by__.unwrap_or_default(),
7326                    order_by: order_by__.unwrap_or_default(),
7327                    state_table: state_table__,
7328                    cache_policy: cache_policy__.unwrap_or_default(),
7329                })
7330            }
7331        }
7332        deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
7333    }
7334}
7335impl serde::Serialize for PauseMutation {
7336    #[allow(deprecated)]
7337    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7338    where
7339        S: serde::Serializer,
7340    {
7341        use serde::ser::SerializeStruct;
7342        let len = 0;
7343        let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
7344        struct_ser.end()
7345    }
7346}
7347impl<'de> serde::Deserialize<'de> for PauseMutation {
7348    #[allow(deprecated)]
7349    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7350    where
7351        D: serde::Deserializer<'de>,
7352    {
7353        const FIELDS: &[&str] = &[
7354        ];
7355
7356        #[allow(clippy::enum_variant_names)]
7357        enum GeneratedField {
7358        }
7359        impl<'de> serde::Deserialize<'de> for GeneratedField {
7360            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7361            where
7362                D: serde::Deserializer<'de>,
7363            {
7364                struct GeneratedVisitor;
7365
7366                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7367                    type Value = GeneratedField;
7368
7369                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7370                        write!(formatter, "expected one of: {:?}", &FIELDS)
7371                    }
7372
7373                    #[allow(unused_variables)]
7374                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7375                    where
7376                        E: serde::de::Error,
7377                    {
7378                            Err(serde::de::Error::unknown_field(value, FIELDS))
7379                    }
7380                }
7381                deserializer.deserialize_identifier(GeneratedVisitor)
7382            }
7383        }
7384        struct GeneratedVisitor;
7385        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7386            type Value = PauseMutation;
7387
7388            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7389                formatter.write_str("struct stream_plan.PauseMutation")
7390            }
7391
7392            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
7393                where
7394                    V: serde::de::MapAccess<'de>,
7395            {
7396                while map_.next_key::<GeneratedField>()?.is_some() {
7397                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7398                }
7399                Ok(PauseMutation {
7400                })
7401            }
7402        }
7403        deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
7404    }
7405}
7406impl serde::Serialize for ProjectNode {
7407    #[allow(deprecated)]
7408    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7409    where
7410        S: serde::Serializer,
7411    {
7412        use serde::ser::SerializeStruct;
7413        let mut len = 0;
7414        if !self.select_list.is_empty() {
7415            len += 1;
7416        }
7417        if !self.watermark_input_cols.is_empty() {
7418            len += 1;
7419        }
7420        if !self.watermark_output_cols.is_empty() {
7421            len += 1;
7422        }
7423        if !self.nondecreasing_exprs.is_empty() {
7424            len += 1;
7425        }
7426        if self.noop_update_hint {
7427            len += 1;
7428        }
7429        let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
7430        if !self.select_list.is_empty() {
7431            struct_ser.serialize_field("selectList", &self.select_list)?;
7432        }
7433        if !self.watermark_input_cols.is_empty() {
7434            struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
7435        }
7436        if !self.watermark_output_cols.is_empty() {
7437            struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
7438        }
7439        if !self.nondecreasing_exprs.is_empty() {
7440            struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
7441        }
7442        if self.noop_update_hint {
7443            struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
7444        }
7445        struct_ser.end()
7446    }
7447}
7448impl<'de> serde::Deserialize<'de> for ProjectNode {
7449    #[allow(deprecated)]
7450    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7451    where
7452        D: serde::Deserializer<'de>,
7453    {
7454        const FIELDS: &[&str] = &[
7455            "select_list",
7456            "selectList",
7457            "watermark_input_cols",
7458            "watermarkInputCols",
7459            "watermark_output_cols",
7460            "watermarkOutputCols",
7461            "nondecreasing_exprs",
7462            "nondecreasingExprs",
7463            "noop_update_hint",
7464            "noopUpdateHint",
7465        ];
7466
7467        #[allow(clippy::enum_variant_names)]
7468        enum GeneratedField {
7469            SelectList,
7470            WatermarkInputCols,
7471            WatermarkOutputCols,
7472            NondecreasingExprs,
7473            NoopUpdateHint,
7474        }
7475        impl<'de> serde::Deserialize<'de> for GeneratedField {
7476            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7477            where
7478                D: serde::Deserializer<'de>,
7479            {
7480                struct GeneratedVisitor;
7481
7482                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7483                    type Value = GeneratedField;
7484
7485                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7486                        write!(formatter, "expected one of: {:?}", &FIELDS)
7487                    }
7488
7489                    #[allow(unused_variables)]
7490                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7491                    where
7492                        E: serde::de::Error,
7493                    {
7494                        match value {
7495                            "selectList" | "select_list" => Ok(GeneratedField::SelectList),
7496                            "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
7497                            "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
7498                            "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
7499                            "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
7500                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7501                        }
7502                    }
7503                }
7504                deserializer.deserialize_identifier(GeneratedVisitor)
7505            }
7506        }
7507        struct GeneratedVisitor;
7508        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7509            type Value = ProjectNode;
7510
7511            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7512                formatter.write_str("struct stream_plan.ProjectNode")
7513            }
7514
7515            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
7516                where
7517                    V: serde::de::MapAccess<'de>,
7518            {
7519                let mut select_list__ = None;
7520                let mut watermark_input_cols__ = None;
7521                let mut watermark_output_cols__ = None;
7522                let mut nondecreasing_exprs__ = None;
7523                let mut noop_update_hint__ = None;
7524                while let Some(k) = map_.next_key()? {
7525                    match k {
7526                        GeneratedField::SelectList => {
7527                            if select_list__.is_some() {
7528                                return Err(serde::de::Error::duplicate_field("selectList"));
7529                            }
7530                            select_list__ = Some(map_.next_value()?);
7531                        }
7532                        GeneratedField::WatermarkInputCols => {
7533                            if watermark_input_cols__.is_some() {
7534                                return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
7535                            }
7536                            watermark_input_cols__ = 
7537                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7538                                    .into_iter().map(|x| x.0).collect())
7539                            ;
7540                        }
7541                        GeneratedField::WatermarkOutputCols => {
7542                            if watermark_output_cols__.is_some() {
7543                                return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
7544                            }
7545                            watermark_output_cols__ = 
7546                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7547                                    .into_iter().map(|x| x.0).collect())
7548                            ;
7549                        }
7550                        GeneratedField::NondecreasingExprs => {
7551                            if nondecreasing_exprs__.is_some() {
7552                                return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
7553                            }
7554                            nondecreasing_exprs__ = 
7555                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7556                                    .into_iter().map(|x| x.0).collect())
7557                            ;
7558                        }
7559                        GeneratedField::NoopUpdateHint => {
7560                            if noop_update_hint__.is_some() {
7561                                return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
7562                            }
7563                            noop_update_hint__ = Some(map_.next_value()?);
7564                        }
7565                    }
7566                }
7567                Ok(ProjectNode {
7568                    select_list: select_list__.unwrap_or_default(),
7569                    watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
7570                    watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
7571                    nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
7572                    noop_update_hint: noop_update_hint__.unwrap_or_default(),
7573                })
7574            }
7575        }
7576        deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
7577    }
7578}
7579impl serde::Serialize for ProjectSetNode {
7580    #[allow(deprecated)]
7581    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7582    where
7583        S: serde::Serializer,
7584    {
7585        use serde::ser::SerializeStruct;
7586        let mut len = 0;
7587        if !self.select_list.is_empty() {
7588            len += 1;
7589        }
7590        if !self.watermark_input_cols.is_empty() {
7591            len += 1;
7592        }
7593        if !self.watermark_expr_indices.is_empty() {
7594            len += 1;
7595        }
7596        if !self.nondecreasing_exprs.is_empty() {
7597            len += 1;
7598        }
7599        let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
7600        if !self.select_list.is_empty() {
7601            struct_ser.serialize_field("selectList", &self.select_list)?;
7602        }
7603        if !self.watermark_input_cols.is_empty() {
7604            struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
7605        }
7606        if !self.watermark_expr_indices.is_empty() {
7607            struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
7608        }
7609        if !self.nondecreasing_exprs.is_empty() {
7610            struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
7611        }
7612        struct_ser.end()
7613    }
7614}
7615impl<'de> serde::Deserialize<'de> for ProjectSetNode {
7616    #[allow(deprecated)]
7617    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7618    where
7619        D: serde::Deserializer<'de>,
7620    {
7621        const FIELDS: &[&str] = &[
7622            "select_list",
7623            "selectList",
7624            "watermark_input_cols",
7625            "watermarkInputCols",
7626            "watermark_expr_indices",
7627            "watermarkExprIndices",
7628            "nondecreasing_exprs",
7629            "nondecreasingExprs",
7630        ];
7631
7632        #[allow(clippy::enum_variant_names)]
7633        enum GeneratedField {
7634            SelectList,
7635            WatermarkInputCols,
7636            WatermarkExprIndices,
7637            NondecreasingExprs,
7638        }
7639        impl<'de> serde::Deserialize<'de> for GeneratedField {
7640            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7641            where
7642                D: serde::Deserializer<'de>,
7643            {
7644                struct GeneratedVisitor;
7645
7646                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7647                    type Value = GeneratedField;
7648
7649                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7650                        write!(formatter, "expected one of: {:?}", &FIELDS)
7651                    }
7652
7653                    #[allow(unused_variables)]
7654                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7655                    where
7656                        E: serde::de::Error,
7657                    {
7658                        match value {
7659                            "selectList" | "select_list" => Ok(GeneratedField::SelectList),
7660                            "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
7661                            "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
7662                            "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
7663                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7664                        }
7665                    }
7666                }
7667                deserializer.deserialize_identifier(GeneratedVisitor)
7668            }
7669        }
7670        struct GeneratedVisitor;
7671        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7672            type Value = ProjectSetNode;
7673
7674            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7675                formatter.write_str("struct stream_plan.ProjectSetNode")
7676            }
7677
7678            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
7679                where
7680                    V: serde::de::MapAccess<'de>,
7681            {
7682                let mut select_list__ = None;
7683                let mut watermark_input_cols__ = None;
7684                let mut watermark_expr_indices__ = None;
7685                let mut nondecreasing_exprs__ = None;
7686                while let Some(k) = map_.next_key()? {
7687                    match k {
7688                        GeneratedField::SelectList => {
7689                            if select_list__.is_some() {
7690                                return Err(serde::de::Error::duplicate_field("selectList"));
7691                            }
7692                            select_list__ = Some(map_.next_value()?);
7693                        }
7694                        GeneratedField::WatermarkInputCols => {
7695                            if watermark_input_cols__.is_some() {
7696                                return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
7697                            }
7698                            watermark_input_cols__ = 
7699                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7700                                    .into_iter().map(|x| x.0).collect())
7701                            ;
7702                        }
7703                        GeneratedField::WatermarkExprIndices => {
7704                            if watermark_expr_indices__.is_some() {
7705                                return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
7706                            }
7707                            watermark_expr_indices__ = 
7708                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7709                                    .into_iter().map(|x| x.0).collect())
7710                            ;
7711                        }
7712                        GeneratedField::NondecreasingExprs => {
7713                            if nondecreasing_exprs__.is_some() {
7714                                return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
7715                            }
7716                            nondecreasing_exprs__ = 
7717                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7718                                    .into_iter().map(|x| x.0).collect())
7719                            ;
7720                        }
7721                    }
7722                }
7723                Ok(ProjectSetNode {
7724                    select_list: select_list__.unwrap_or_default(),
7725                    watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
7726                    watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
7727                    nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
7728                })
7729            }
7730        }
7731        deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
7732    }
7733}
7734impl serde::Serialize for ResumeMutation {
7735    #[allow(deprecated)]
7736    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7737    where
7738        S: serde::Serializer,
7739    {
7740        use serde::ser::SerializeStruct;
7741        let len = 0;
7742        let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
7743        struct_ser.end()
7744    }
7745}
7746impl<'de> serde::Deserialize<'de> for ResumeMutation {
7747    #[allow(deprecated)]
7748    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7749    where
7750        D: serde::Deserializer<'de>,
7751    {
7752        const FIELDS: &[&str] = &[
7753        ];
7754
7755        #[allow(clippy::enum_variant_names)]
7756        enum GeneratedField {
7757        }
7758        impl<'de> serde::Deserialize<'de> for GeneratedField {
7759            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7760            where
7761                D: serde::Deserializer<'de>,
7762            {
7763                struct GeneratedVisitor;
7764
7765                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7766                    type Value = GeneratedField;
7767
7768                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7769                        write!(formatter, "expected one of: {:?}", &FIELDS)
7770                    }
7771
7772                    #[allow(unused_variables)]
7773                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7774                    where
7775                        E: serde::de::Error,
7776                    {
7777                            Err(serde::de::Error::unknown_field(value, FIELDS))
7778                    }
7779                }
7780                deserializer.deserialize_identifier(GeneratedVisitor)
7781            }
7782        }
7783        struct GeneratedVisitor;
7784        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7785            type Value = ResumeMutation;
7786
7787            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7788                formatter.write_str("struct stream_plan.ResumeMutation")
7789            }
7790
7791            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
7792                where
7793                    V: serde::de::MapAccess<'de>,
7794            {
7795                while map_.next_key::<GeneratedField>()?.is_some() {
7796                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7797                }
7798                Ok(ResumeMutation {
7799                })
7800            }
7801        }
7802        deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
7803    }
7804}
7805impl serde::Serialize for RowIdGenNode {
7806    #[allow(deprecated)]
7807    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7808    where
7809        S: serde::Serializer,
7810    {
7811        use serde::ser::SerializeStruct;
7812        let mut len = 0;
7813        if self.row_id_index != 0 {
7814            len += 1;
7815        }
7816        let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
7817        if self.row_id_index != 0 {
7818            #[allow(clippy::needless_borrow)]
7819            #[allow(clippy::needless_borrows_for_generic_args)]
7820            struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
7821        }
7822        struct_ser.end()
7823    }
7824}
7825impl<'de> serde::Deserialize<'de> for RowIdGenNode {
7826    #[allow(deprecated)]
7827    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7828    where
7829        D: serde::Deserializer<'de>,
7830    {
7831        const FIELDS: &[&str] = &[
7832            "row_id_index",
7833            "rowIdIndex",
7834        ];
7835
7836        #[allow(clippy::enum_variant_names)]
7837        enum GeneratedField {
7838            RowIdIndex,
7839        }
7840        impl<'de> serde::Deserialize<'de> for GeneratedField {
7841            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7842            where
7843                D: serde::Deserializer<'de>,
7844            {
7845                struct GeneratedVisitor;
7846
7847                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7848                    type Value = GeneratedField;
7849
7850                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7851                        write!(formatter, "expected one of: {:?}", &FIELDS)
7852                    }
7853
7854                    #[allow(unused_variables)]
7855                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7856                    where
7857                        E: serde::de::Error,
7858                    {
7859                        match value {
7860                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
7861                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7862                        }
7863                    }
7864                }
7865                deserializer.deserialize_identifier(GeneratedVisitor)
7866            }
7867        }
7868        struct GeneratedVisitor;
7869        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7870            type Value = RowIdGenNode;
7871
7872            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7873                formatter.write_str("struct stream_plan.RowIdGenNode")
7874            }
7875
7876            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
7877                where
7878                    V: serde::de::MapAccess<'de>,
7879            {
7880                let mut row_id_index__ = None;
7881                while let Some(k) = map_.next_key()? {
7882                    match k {
7883                        GeneratedField::RowIdIndex => {
7884                            if row_id_index__.is_some() {
7885                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
7886                            }
7887                            row_id_index__ = 
7888                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7889                            ;
7890                        }
7891                    }
7892                }
7893                Ok(RowIdGenNode {
7894                    row_id_index: row_id_index__.unwrap_or_default(),
7895                })
7896            }
7897        }
7898        deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
7899    }
7900}
7901impl serde::Serialize for RowMergeNode {
7902    #[allow(deprecated)]
7903    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7904    where
7905        S: serde::Serializer,
7906    {
7907        use serde::ser::SerializeStruct;
7908        let mut len = 0;
7909        if self.lhs_mapping.is_some() {
7910            len += 1;
7911        }
7912        if self.rhs_mapping.is_some() {
7913            len += 1;
7914        }
7915        let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
7916        if let Some(v) = self.lhs_mapping.as_ref() {
7917            struct_ser.serialize_field("lhsMapping", v)?;
7918        }
7919        if let Some(v) = self.rhs_mapping.as_ref() {
7920            struct_ser.serialize_field("rhsMapping", v)?;
7921        }
7922        struct_ser.end()
7923    }
7924}
7925impl<'de> serde::Deserialize<'de> for RowMergeNode {
7926    #[allow(deprecated)]
7927    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7928    where
7929        D: serde::Deserializer<'de>,
7930    {
7931        const FIELDS: &[&str] = &[
7932            "lhs_mapping",
7933            "lhsMapping",
7934            "rhs_mapping",
7935            "rhsMapping",
7936        ];
7937
7938        #[allow(clippy::enum_variant_names)]
7939        enum GeneratedField {
7940            LhsMapping,
7941            RhsMapping,
7942        }
7943        impl<'de> serde::Deserialize<'de> for GeneratedField {
7944            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7945            where
7946                D: serde::Deserializer<'de>,
7947            {
7948                struct GeneratedVisitor;
7949
7950                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7951                    type Value = GeneratedField;
7952
7953                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7954                        write!(formatter, "expected one of: {:?}", &FIELDS)
7955                    }
7956
7957                    #[allow(unused_variables)]
7958                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7959                    where
7960                        E: serde::de::Error,
7961                    {
7962                        match value {
7963                            "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
7964                            "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
7965                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7966                        }
7967                    }
7968                }
7969                deserializer.deserialize_identifier(GeneratedVisitor)
7970            }
7971        }
7972        struct GeneratedVisitor;
7973        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7974            type Value = RowMergeNode;
7975
7976            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7977                formatter.write_str("struct stream_plan.RowMergeNode")
7978            }
7979
7980            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
7981                where
7982                    V: serde::de::MapAccess<'de>,
7983            {
7984                let mut lhs_mapping__ = None;
7985                let mut rhs_mapping__ = None;
7986                while let Some(k) = map_.next_key()? {
7987                    match k {
7988                        GeneratedField::LhsMapping => {
7989                            if lhs_mapping__.is_some() {
7990                                return Err(serde::de::Error::duplicate_field("lhsMapping"));
7991                            }
7992                            lhs_mapping__ = map_.next_value()?;
7993                        }
7994                        GeneratedField::RhsMapping => {
7995                            if rhs_mapping__.is_some() {
7996                                return Err(serde::de::Error::duplicate_field("rhsMapping"));
7997                            }
7998                            rhs_mapping__ = map_.next_value()?;
7999                        }
8000                    }
8001                }
8002                Ok(RowMergeNode {
8003                    lhs_mapping: lhs_mapping__,
8004                    rhs_mapping: rhs_mapping__,
8005                })
8006            }
8007        }
8008        deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
8009    }
8010}
8011impl serde::Serialize for SimpleAggNode {
8012    #[allow(deprecated)]
8013    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8014    where
8015        S: serde::Serializer,
8016    {
8017        use serde::ser::SerializeStruct;
8018        let mut len = 0;
8019        if !self.agg_calls.is_empty() {
8020            len += 1;
8021        }
8022        if !self.distribution_key.is_empty() {
8023            len += 1;
8024        }
8025        if !self.agg_call_states.is_empty() {
8026            len += 1;
8027        }
8028        if self.intermediate_state_table.is_some() {
8029            len += 1;
8030        }
8031        if self.is_append_only {
8032            len += 1;
8033        }
8034        if !self.distinct_dedup_tables.is_empty() {
8035            len += 1;
8036        }
8037        if self.row_count_index != 0 {
8038            len += 1;
8039        }
8040        if self.version != 0 {
8041            len += 1;
8042        }
8043        if self.must_output_per_barrier {
8044            len += 1;
8045        }
8046        let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
8047        if !self.agg_calls.is_empty() {
8048            struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
8049        }
8050        if !self.distribution_key.is_empty() {
8051            struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
8052        }
8053        if !self.agg_call_states.is_empty() {
8054            struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
8055        }
8056        if let Some(v) = self.intermediate_state_table.as_ref() {
8057            struct_ser.serialize_field("intermediateStateTable", v)?;
8058        }
8059        if self.is_append_only {
8060            struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
8061        }
8062        if !self.distinct_dedup_tables.is_empty() {
8063            struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
8064        }
8065        if self.row_count_index != 0 {
8066            struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
8067        }
8068        if self.version != 0 {
8069            let v = AggNodeVersion::try_from(self.version)
8070                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
8071            struct_ser.serialize_field("version", &v)?;
8072        }
8073        if self.must_output_per_barrier {
8074            struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
8075        }
8076        struct_ser.end()
8077    }
8078}
8079impl<'de> serde::Deserialize<'de> for SimpleAggNode {
8080    #[allow(deprecated)]
8081    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8082    where
8083        D: serde::Deserializer<'de>,
8084    {
8085        const FIELDS: &[&str] = &[
8086            "agg_calls",
8087            "aggCalls",
8088            "distribution_key",
8089            "distributionKey",
8090            "agg_call_states",
8091            "aggCallStates",
8092            "intermediate_state_table",
8093            "intermediateStateTable",
8094            "is_append_only",
8095            "isAppendOnly",
8096            "distinct_dedup_tables",
8097            "distinctDedupTables",
8098            "row_count_index",
8099            "rowCountIndex",
8100            "version",
8101            "must_output_per_barrier",
8102            "mustOutputPerBarrier",
8103        ];
8104
8105        #[allow(clippy::enum_variant_names)]
8106        enum GeneratedField {
8107            AggCalls,
8108            DistributionKey,
8109            AggCallStates,
8110            IntermediateStateTable,
8111            IsAppendOnly,
8112            DistinctDedupTables,
8113            RowCountIndex,
8114            Version,
8115            MustOutputPerBarrier,
8116        }
8117        impl<'de> serde::Deserialize<'de> for GeneratedField {
8118            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8119            where
8120                D: serde::Deserializer<'de>,
8121            {
8122                struct GeneratedVisitor;
8123
8124                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8125                    type Value = GeneratedField;
8126
8127                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8128                        write!(formatter, "expected one of: {:?}", &FIELDS)
8129                    }
8130
8131                    #[allow(unused_variables)]
8132                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8133                    where
8134                        E: serde::de::Error,
8135                    {
8136                        match value {
8137                            "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
8138                            "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
8139                            "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
8140                            "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
8141                            "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
8142                            "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
8143                            "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
8144                            "version" => Ok(GeneratedField::Version),
8145                            "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
8146                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8147                        }
8148                    }
8149                }
8150                deserializer.deserialize_identifier(GeneratedVisitor)
8151            }
8152        }
8153        struct GeneratedVisitor;
8154        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8155            type Value = SimpleAggNode;
8156
8157            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8158                formatter.write_str("struct stream_plan.SimpleAggNode")
8159            }
8160
8161            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
8162                where
8163                    V: serde::de::MapAccess<'de>,
8164            {
8165                let mut agg_calls__ = None;
8166                let mut distribution_key__ = None;
8167                let mut agg_call_states__ = None;
8168                let mut intermediate_state_table__ = None;
8169                let mut is_append_only__ = None;
8170                let mut distinct_dedup_tables__ = None;
8171                let mut row_count_index__ = None;
8172                let mut version__ = None;
8173                let mut must_output_per_barrier__ = None;
8174                while let Some(k) = map_.next_key()? {
8175                    match k {
8176                        GeneratedField::AggCalls => {
8177                            if agg_calls__.is_some() {
8178                                return Err(serde::de::Error::duplicate_field("aggCalls"));
8179                            }
8180                            agg_calls__ = Some(map_.next_value()?);
8181                        }
8182                        GeneratedField::DistributionKey => {
8183                            if distribution_key__.is_some() {
8184                                return Err(serde::de::Error::duplicate_field("distributionKey"));
8185                            }
8186                            distribution_key__ = 
8187                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8188                                    .into_iter().map(|x| x.0).collect())
8189                            ;
8190                        }
8191                        GeneratedField::AggCallStates => {
8192                            if agg_call_states__.is_some() {
8193                                return Err(serde::de::Error::duplicate_field("aggCallStates"));
8194                            }
8195                            agg_call_states__ = Some(map_.next_value()?);
8196                        }
8197                        GeneratedField::IntermediateStateTable => {
8198                            if intermediate_state_table__.is_some() {
8199                                return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
8200                            }
8201                            intermediate_state_table__ = map_.next_value()?;
8202                        }
8203                        GeneratedField::IsAppendOnly => {
8204                            if is_append_only__.is_some() {
8205                                return Err(serde::de::Error::duplicate_field("isAppendOnly"));
8206                            }
8207                            is_append_only__ = Some(map_.next_value()?);
8208                        }
8209                        GeneratedField::DistinctDedupTables => {
8210                            if distinct_dedup_tables__.is_some() {
8211                                return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
8212                            }
8213                            distinct_dedup_tables__ = Some(
8214                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8215                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
8216                            );
8217                        }
8218                        GeneratedField::RowCountIndex => {
8219                            if row_count_index__.is_some() {
8220                                return Err(serde::de::Error::duplicate_field("rowCountIndex"));
8221                            }
8222                            row_count_index__ = 
8223                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8224                            ;
8225                        }
8226                        GeneratedField::Version => {
8227                            if version__.is_some() {
8228                                return Err(serde::de::Error::duplicate_field("version"));
8229                            }
8230                            version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
8231                        }
8232                        GeneratedField::MustOutputPerBarrier => {
8233                            if must_output_per_barrier__.is_some() {
8234                                return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
8235                            }
8236                            must_output_per_barrier__ = Some(map_.next_value()?);
8237                        }
8238                    }
8239                }
8240                Ok(SimpleAggNode {
8241                    agg_calls: agg_calls__.unwrap_or_default(),
8242                    distribution_key: distribution_key__.unwrap_or_default(),
8243                    agg_call_states: agg_call_states__.unwrap_or_default(),
8244                    intermediate_state_table: intermediate_state_table__,
8245                    is_append_only: is_append_only__.unwrap_or_default(),
8246                    distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
8247                    row_count_index: row_count_index__.unwrap_or_default(),
8248                    version: version__.unwrap_or_default(),
8249                    must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
8250                })
8251            }
8252        }
8253        deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
8254    }
8255}
8256impl serde::Serialize for SinkDesc {
8257    #[allow(deprecated)]
8258    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8259    where
8260        S: serde::Serializer,
8261    {
8262        use serde::ser::SerializeStruct;
8263        let mut len = 0;
8264        if self.id != 0 {
8265            len += 1;
8266        }
8267        if !self.name.is_empty() {
8268            len += 1;
8269        }
8270        if !self.definition.is_empty() {
8271            len += 1;
8272        }
8273        if !self.plan_pk.is_empty() {
8274            len += 1;
8275        }
8276        if !self.downstream_pk.is_empty() {
8277            len += 1;
8278        }
8279        if !self.distribution_key.is_empty() {
8280            len += 1;
8281        }
8282        if !self.properties.is_empty() {
8283            len += 1;
8284        }
8285        if self.sink_type != 0 {
8286            len += 1;
8287        }
8288        if !self.column_catalogs.is_empty() {
8289            len += 1;
8290        }
8291        if !self.db_name.is_empty() {
8292            len += 1;
8293        }
8294        if !self.sink_from_name.is_empty() {
8295            len += 1;
8296        }
8297        if self.format_desc.is_some() {
8298            len += 1;
8299        }
8300        if self.target_table.is_some() {
8301            len += 1;
8302        }
8303        if self.extra_partition_col_idx.is_some() {
8304            len += 1;
8305        }
8306        if !self.secret_refs.is_empty() {
8307            len += 1;
8308        }
8309        let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
8310        if self.id != 0 {
8311            struct_ser.serialize_field("id", &self.id)?;
8312        }
8313        if !self.name.is_empty() {
8314            struct_ser.serialize_field("name", &self.name)?;
8315        }
8316        if !self.definition.is_empty() {
8317            struct_ser.serialize_field("definition", &self.definition)?;
8318        }
8319        if !self.plan_pk.is_empty() {
8320            struct_ser.serialize_field("planPk", &self.plan_pk)?;
8321        }
8322        if !self.downstream_pk.is_empty() {
8323            struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
8324        }
8325        if !self.distribution_key.is_empty() {
8326            struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
8327        }
8328        if !self.properties.is_empty() {
8329            struct_ser.serialize_field("properties", &self.properties)?;
8330        }
8331        if self.sink_type != 0 {
8332            let v = super::catalog::SinkType::try_from(self.sink_type)
8333                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
8334            struct_ser.serialize_field("sinkType", &v)?;
8335        }
8336        if !self.column_catalogs.is_empty() {
8337            struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
8338        }
8339        if !self.db_name.is_empty() {
8340            struct_ser.serialize_field("dbName", &self.db_name)?;
8341        }
8342        if !self.sink_from_name.is_empty() {
8343            struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
8344        }
8345        if let Some(v) = self.format_desc.as_ref() {
8346            struct_ser.serialize_field("formatDesc", v)?;
8347        }
8348        if let Some(v) = self.target_table.as_ref() {
8349            struct_ser.serialize_field("targetTable", v)?;
8350        }
8351        if let Some(v) = self.extra_partition_col_idx.as_ref() {
8352            #[allow(clippy::needless_borrow)]
8353            #[allow(clippy::needless_borrows_for_generic_args)]
8354            struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
8355        }
8356        if !self.secret_refs.is_empty() {
8357            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
8358        }
8359        struct_ser.end()
8360    }
8361}
8362impl<'de> serde::Deserialize<'de> for SinkDesc {
8363    #[allow(deprecated)]
8364    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8365    where
8366        D: serde::Deserializer<'de>,
8367    {
8368        const FIELDS: &[&str] = &[
8369            "id",
8370            "name",
8371            "definition",
8372            "plan_pk",
8373            "planPk",
8374            "downstream_pk",
8375            "downstreamPk",
8376            "distribution_key",
8377            "distributionKey",
8378            "properties",
8379            "sink_type",
8380            "sinkType",
8381            "column_catalogs",
8382            "columnCatalogs",
8383            "db_name",
8384            "dbName",
8385            "sink_from_name",
8386            "sinkFromName",
8387            "format_desc",
8388            "formatDesc",
8389            "target_table",
8390            "targetTable",
8391            "extra_partition_col_idx",
8392            "extraPartitionColIdx",
8393            "secret_refs",
8394            "secretRefs",
8395        ];
8396
8397        #[allow(clippy::enum_variant_names)]
8398        enum GeneratedField {
8399            Id,
8400            Name,
8401            Definition,
8402            PlanPk,
8403            DownstreamPk,
8404            DistributionKey,
8405            Properties,
8406            SinkType,
8407            ColumnCatalogs,
8408            DbName,
8409            SinkFromName,
8410            FormatDesc,
8411            TargetTable,
8412            ExtraPartitionColIdx,
8413            SecretRefs,
8414        }
8415        impl<'de> serde::Deserialize<'de> for GeneratedField {
8416            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8417            where
8418                D: serde::Deserializer<'de>,
8419            {
8420                struct GeneratedVisitor;
8421
8422                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8423                    type Value = GeneratedField;
8424
8425                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8426                        write!(formatter, "expected one of: {:?}", &FIELDS)
8427                    }
8428
8429                    #[allow(unused_variables)]
8430                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8431                    where
8432                        E: serde::de::Error,
8433                    {
8434                        match value {
8435                            "id" => Ok(GeneratedField::Id),
8436                            "name" => Ok(GeneratedField::Name),
8437                            "definition" => Ok(GeneratedField::Definition),
8438                            "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
8439                            "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
8440                            "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
8441                            "properties" => Ok(GeneratedField::Properties),
8442                            "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
8443                            "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
8444                            "dbName" | "db_name" => Ok(GeneratedField::DbName),
8445                            "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
8446                            "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
8447                            "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
8448                            "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
8449                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
8450                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8451                        }
8452                    }
8453                }
8454                deserializer.deserialize_identifier(GeneratedVisitor)
8455            }
8456        }
8457        struct GeneratedVisitor;
8458        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8459            type Value = SinkDesc;
8460
8461            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8462                formatter.write_str("struct stream_plan.SinkDesc")
8463            }
8464
8465            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
8466                where
8467                    V: serde::de::MapAccess<'de>,
8468            {
8469                let mut id__ = None;
8470                let mut name__ = None;
8471                let mut definition__ = None;
8472                let mut plan_pk__ = None;
8473                let mut downstream_pk__ = None;
8474                let mut distribution_key__ = None;
8475                let mut properties__ = None;
8476                let mut sink_type__ = None;
8477                let mut column_catalogs__ = None;
8478                let mut db_name__ = None;
8479                let mut sink_from_name__ = None;
8480                let mut format_desc__ = None;
8481                let mut target_table__ = None;
8482                let mut extra_partition_col_idx__ = None;
8483                let mut secret_refs__ = None;
8484                while let Some(k) = map_.next_key()? {
8485                    match k {
8486                        GeneratedField::Id => {
8487                            if id__.is_some() {
8488                                return Err(serde::de::Error::duplicate_field("id"));
8489                            }
8490                            id__ = 
8491                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8492                            ;
8493                        }
8494                        GeneratedField::Name => {
8495                            if name__.is_some() {
8496                                return Err(serde::de::Error::duplicate_field("name"));
8497                            }
8498                            name__ = Some(map_.next_value()?);
8499                        }
8500                        GeneratedField::Definition => {
8501                            if definition__.is_some() {
8502                                return Err(serde::de::Error::duplicate_field("definition"));
8503                            }
8504                            definition__ = Some(map_.next_value()?);
8505                        }
8506                        GeneratedField::PlanPk => {
8507                            if plan_pk__.is_some() {
8508                                return Err(serde::de::Error::duplicate_field("planPk"));
8509                            }
8510                            plan_pk__ = Some(map_.next_value()?);
8511                        }
8512                        GeneratedField::DownstreamPk => {
8513                            if downstream_pk__.is_some() {
8514                                return Err(serde::de::Error::duplicate_field("downstreamPk"));
8515                            }
8516                            downstream_pk__ = 
8517                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8518                                    .into_iter().map(|x| x.0).collect())
8519                            ;
8520                        }
8521                        GeneratedField::DistributionKey => {
8522                            if distribution_key__.is_some() {
8523                                return Err(serde::de::Error::duplicate_field("distributionKey"));
8524                            }
8525                            distribution_key__ = 
8526                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8527                                    .into_iter().map(|x| x.0).collect())
8528                            ;
8529                        }
8530                        GeneratedField::Properties => {
8531                            if properties__.is_some() {
8532                                return Err(serde::de::Error::duplicate_field("properties"));
8533                            }
8534                            properties__ = Some(
8535                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
8536                            );
8537                        }
8538                        GeneratedField::SinkType => {
8539                            if sink_type__.is_some() {
8540                                return Err(serde::de::Error::duplicate_field("sinkType"));
8541                            }
8542                            sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
8543                        }
8544                        GeneratedField::ColumnCatalogs => {
8545                            if column_catalogs__.is_some() {
8546                                return Err(serde::de::Error::duplicate_field("columnCatalogs"));
8547                            }
8548                            column_catalogs__ = Some(map_.next_value()?);
8549                        }
8550                        GeneratedField::DbName => {
8551                            if db_name__.is_some() {
8552                                return Err(serde::de::Error::duplicate_field("dbName"));
8553                            }
8554                            db_name__ = Some(map_.next_value()?);
8555                        }
8556                        GeneratedField::SinkFromName => {
8557                            if sink_from_name__.is_some() {
8558                                return Err(serde::de::Error::duplicate_field("sinkFromName"));
8559                            }
8560                            sink_from_name__ = Some(map_.next_value()?);
8561                        }
8562                        GeneratedField::FormatDesc => {
8563                            if format_desc__.is_some() {
8564                                return Err(serde::de::Error::duplicate_field("formatDesc"));
8565                            }
8566                            format_desc__ = map_.next_value()?;
8567                        }
8568                        GeneratedField::TargetTable => {
8569                            if target_table__.is_some() {
8570                                return Err(serde::de::Error::duplicate_field("targetTable"));
8571                            }
8572                            target_table__ = 
8573                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8574                            ;
8575                        }
8576                        GeneratedField::ExtraPartitionColIdx => {
8577                            if extra_partition_col_idx__.is_some() {
8578                                return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
8579                            }
8580                            extra_partition_col_idx__ = 
8581                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8582                            ;
8583                        }
8584                        GeneratedField::SecretRefs => {
8585                            if secret_refs__.is_some() {
8586                                return Err(serde::de::Error::duplicate_field("secretRefs"));
8587                            }
8588                            secret_refs__ = Some(
8589                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
8590                            );
8591                        }
8592                    }
8593                }
8594                Ok(SinkDesc {
8595                    id: id__.unwrap_or_default(),
8596                    name: name__.unwrap_or_default(),
8597                    definition: definition__.unwrap_or_default(),
8598                    plan_pk: plan_pk__.unwrap_or_default(),
8599                    downstream_pk: downstream_pk__.unwrap_or_default(),
8600                    distribution_key: distribution_key__.unwrap_or_default(),
8601                    properties: properties__.unwrap_or_default(),
8602                    sink_type: sink_type__.unwrap_or_default(),
8603                    column_catalogs: column_catalogs__.unwrap_or_default(),
8604                    db_name: db_name__.unwrap_or_default(),
8605                    sink_from_name: sink_from_name__.unwrap_or_default(),
8606                    format_desc: format_desc__,
8607                    target_table: target_table__,
8608                    extra_partition_col_idx: extra_partition_col_idx__,
8609                    secret_refs: secret_refs__.unwrap_or_default(),
8610                })
8611            }
8612        }
8613        deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
8614    }
8615}
8616impl serde::Serialize for SinkLogStoreType {
8617    #[allow(deprecated)]
8618    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8619    where
8620        S: serde::Serializer,
8621    {
8622        let variant = match self {
8623            Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
8624            Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
8625            Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
8626        };
8627        serializer.serialize_str(variant)
8628    }
8629}
8630impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
8631    #[allow(deprecated)]
8632    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8633    where
8634        D: serde::Deserializer<'de>,
8635    {
8636        const FIELDS: &[&str] = &[
8637            "SINK_LOG_STORE_TYPE_UNSPECIFIED",
8638            "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
8639            "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
8640        ];
8641
8642        struct GeneratedVisitor;
8643
8644        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8645            type Value = SinkLogStoreType;
8646
8647            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8648                write!(formatter, "expected one of: {:?}", &FIELDS)
8649            }
8650
8651            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
8652            where
8653                E: serde::de::Error,
8654            {
8655                i32::try_from(v)
8656                    .ok()
8657                    .and_then(|x| x.try_into().ok())
8658                    .ok_or_else(|| {
8659                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
8660                    })
8661            }
8662
8663            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
8664            where
8665                E: serde::de::Error,
8666            {
8667                i32::try_from(v)
8668                    .ok()
8669                    .and_then(|x| x.try_into().ok())
8670                    .ok_or_else(|| {
8671                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
8672                    })
8673            }
8674
8675            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
8676            where
8677                E: serde::de::Error,
8678            {
8679                match value {
8680                    "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
8681                    "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
8682                    "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
8683                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
8684                }
8685            }
8686        }
8687        deserializer.deserialize_any(GeneratedVisitor)
8688    }
8689}
8690impl serde::Serialize for SinkNode {
8691    #[allow(deprecated)]
8692    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8693    where
8694        S: serde::Serializer,
8695    {
8696        use serde::ser::SerializeStruct;
8697        let mut len = 0;
8698        if self.sink_desc.is_some() {
8699            len += 1;
8700        }
8701        if self.table.is_some() {
8702            len += 1;
8703        }
8704        if self.log_store_type != 0 {
8705            len += 1;
8706        }
8707        if self.rate_limit.is_some() {
8708            len += 1;
8709        }
8710        let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
8711        if let Some(v) = self.sink_desc.as_ref() {
8712            struct_ser.serialize_field("sinkDesc", v)?;
8713        }
8714        if let Some(v) = self.table.as_ref() {
8715            struct_ser.serialize_field("table", v)?;
8716        }
8717        if self.log_store_type != 0 {
8718            let v = SinkLogStoreType::try_from(self.log_store_type)
8719                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
8720            struct_ser.serialize_field("logStoreType", &v)?;
8721        }
8722        if let Some(v) = self.rate_limit.as_ref() {
8723            struct_ser.serialize_field("rateLimit", v)?;
8724        }
8725        struct_ser.end()
8726    }
8727}
8728impl<'de> serde::Deserialize<'de> for SinkNode {
8729    #[allow(deprecated)]
8730    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8731    where
8732        D: serde::Deserializer<'de>,
8733    {
8734        const FIELDS: &[&str] = &[
8735            "sink_desc",
8736            "sinkDesc",
8737            "table",
8738            "log_store_type",
8739            "logStoreType",
8740            "rate_limit",
8741            "rateLimit",
8742        ];
8743
8744        #[allow(clippy::enum_variant_names)]
8745        enum GeneratedField {
8746            SinkDesc,
8747            Table,
8748            LogStoreType,
8749            RateLimit,
8750        }
8751        impl<'de> serde::Deserialize<'de> for GeneratedField {
8752            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8753            where
8754                D: serde::Deserializer<'de>,
8755            {
8756                struct GeneratedVisitor;
8757
8758                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8759                    type Value = GeneratedField;
8760
8761                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8762                        write!(formatter, "expected one of: {:?}", &FIELDS)
8763                    }
8764
8765                    #[allow(unused_variables)]
8766                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8767                    where
8768                        E: serde::de::Error,
8769                    {
8770                        match value {
8771                            "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
8772                            "table" => Ok(GeneratedField::Table),
8773                            "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
8774                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
8775                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8776                        }
8777                    }
8778                }
8779                deserializer.deserialize_identifier(GeneratedVisitor)
8780            }
8781        }
8782        struct GeneratedVisitor;
8783        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8784            type Value = SinkNode;
8785
8786            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8787                formatter.write_str("struct stream_plan.SinkNode")
8788            }
8789
8790            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
8791                where
8792                    V: serde::de::MapAccess<'de>,
8793            {
8794                let mut sink_desc__ = None;
8795                let mut table__ = None;
8796                let mut log_store_type__ = None;
8797                let mut rate_limit__ = None;
8798                while let Some(k) = map_.next_key()? {
8799                    match k {
8800                        GeneratedField::SinkDesc => {
8801                            if sink_desc__.is_some() {
8802                                return Err(serde::de::Error::duplicate_field("sinkDesc"));
8803                            }
8804                            sink_desc__ = map_.next_value()?;
8805                        }
8806                        GeneratedField::Table => {
8807                            if table__.is_some() {
8808                                return Err(serde::de::Error::duplicate_field("table"));
8809                            }
8810                            table__ = map_.next_value()?;
8811                        }
8812                        GeneratedField::LogStoreType => {
8813                            if log_store_type__.is_some() {
8814                                return Err(serde::de::Error::duplicate_field("logStoreType"));
8815                            }
8816                            log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
8817                        }
8818                        GeneratedField::RateLimit => {
8819                            if rate_limit__.is_some() {
8820                                return Err(serde::de::Error::duplicate_field("rateLimit"));
8821                            }
8822                            rate_limit__ = 
8823                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
8824                            ;
8825                        }
8826                    }
8827                }
8828                Ok(SinkNode {
8829                    sink_desc: sink_desc__,
8830                    table: table__,
8831                    log_store_type: log_store_type__.unwrap_or_default(),
8832                    rate_limit: rate_limit__,
8833                })
8834            }
8835        }
8836        deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
8837    }
8838}
8839impl serde::Serialize for SortNode {
8840    #[allow(deprecated)]
8841    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8842    where
8843        S: serde::Serializer,
8844    {
8845        use serde::ser::SerializeStruct;
8846        let mut len = 0;
8847        if self.state_table.is_some() {
8848            len += 1;
8849        }
8850        if self.sort_column_index != 0 {
8851            len += 1;
8852        }
8853        let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
8854        if let Some(v) = self.state_table.as_ref() {
8855            struct_ser.serialize_field("stateTable", v)?;
8856        }
8857        if self.sort_column_index != 0 {
8858            struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
8859        }
8860        struct_ser.end()
8861    }
8862}
8863impl<'de> serde::Deserialize<'de> for SortNode {
8864    #[allow(deprecated)]
8865    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8866    where
8867        D: serde::Deserializer<'de>,
8868    {
8869        const FIELDS: &[&str] = &[
8870            "state_table",
8871            "stateTable",
8872            "sort_column_index",
8873            "sortColumnIndex",
8874        ];
8875
8876        #[allow(clippy::enum_variant_names)]
8877        enum GeneratedField {
8878            StateTable,
8879            SortColumnIndex,
8880        }
8881        impl<'de> serde::Deserialize<'de> for GeneratedField {
8882            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8883            where
8884                D: serde::Deserializer<'de>,
8885            {
8886                struct GeneratedVisitor;
8887
8888                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8889                    type Value = GeneratedField;
8890
8891                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8892                        write!(formatter, "expected one of: {:?}", &FIELDS)
8893                    }
8894
8895                    #[allow(unused_variables)]
8896                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8897                    where
8898                        E: serde::de::Error,
8899                    {
8900                        match value {
8901                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
8902                            "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
8903                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8904                        }
8905                    }
8906                }
8907                deserializer.deserialize_identifier(GeneratedVisitor)
8908            }
8909        }
8910        struct GeneratedVisitor;
8911        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8912            type Value = SortNode;
8913
8914            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8915                formatter.write_str("struct stream_plan.SortNode")
8916            }
8917
8918            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
8919                where
8920                    V: serde::de::MapAccess<'de>,
8921            {
8922                let mut state_table__ = None;
8923                let mut sort_column_index__ = None;
8924                while let Some(k) = map_.next_key()? {
8925                    match k {
8926                        GeneratedField::StateTable => {
8927                            if state_table__.is_some() {
8928                                return Err(serde::de::Error::duplicate_field("stateTable"));
8929                            }
8930                            state_table__ = map_.next_value()?;
8931                        }
8932                        GeneratedField::SortColumnIndex => {
8933                            if sort_column_index__.is_some() {
8934                                return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
8935                            }
8936                            sort_column_index__ = 
8937                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8938                            ;
8939                        }
8940                    }
8941                }
8942                Ok(SortNode {
8943                    state_table: state_table__,
8944                    sort_column_index: sort_column_index__.unwrap_or_default(),
8945                })
8946            }
8947        }
8948        deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
8949    }
8950}
8951impl serde::Serialize for SourceBackfillNode {
8952    #[allow(deprecated)]
8953    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8954    where
8955        S: serde::Serializer,
8956    {
8957        use serde::ser::SerializeStruct;
8958        let mut len = 0;
8959        if self.upstream_source_id != 0 {
8960            len += 1;
8961        }
8962        if self.row_id_index.is_some() {
8963            len += 1;
8964        }
8965        if !self.columns.is_empty() {
8966            len += 1;
8967        }
8968        if self.info.is_some() {
8969            len += 1;
8970        }
8971        if !self.source_name.is_empty() {
8972            len += 1;
8973        }
8974        if !self.with_properties.is_empty() {
8975            len += 1;
8976        }
8977        if self.rate_limit.is_some() {
8978            len += 1;
8979        }
8980        if self.state_table.is_some() {
8981            len += 1;
8982        }
8983        if !self.secret_refs.is_empty() {
8984            len += 1;
8985        }
8986        let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
8987        if self.upstream_source_id != 0 {
8988            struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
8989        }
8990        if let Some(v) = self.row_id_index.as_ref() {
8991            struct_ser.serialize_field("rowIdIndex", v)?;
8992        }
8993        if !self.columns.is_empty() {
8994            struct_ser.serialize_field("columns", &self.columns)?;
8995        }
8996        if let Some(v) = self.info.as_ref() {
8997            struct_ser.serialize_field("info", v)?;
8998        }
8999        if !self.source_name.is_empty() {
9000            struct_ser.serialize_field("sourceName", &self.source_name)?;
9001        }
9002        if !self.with_properties.is_empty() {
9003            struct_ser.serialize_field("withProperties", &self.with_properties)?;
9004        }
9005        if let Some(v) = self.rate_limit.as_ref() {
9006            struct_ser.serialize_field("rateLimit", v)?;
9007        }
9008        if let Some(v) = self.state_table.as_ref() {
9009            struct_ser.serialize_field("stateTable", v)?;
9010        }
9011        if !self.secret_refs.is_empty() {
9012            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
9013        }
9014        struct_ser.end()
9015    }
9016}
9017impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
9018    #[allow(deprecated)]
9019    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9020    where
9021        D: serde::Deserializer<'de>,
9022    {
9023        const FIELDS: &[&str] = &[
9024            "upstream_source_id",
9025            "upstreamSourceId",
9026            "row_id_index",
9027            "rowIdIndex",
9028            "columns",
9029            "info",
9030            "source_name",
9031            "sourceName",
9032            "with_properties",
9033            "withProperties",
9034            "rate_limit",
9035            "rateLimit",
9036            "state_table",
9037            "stateTable",
9038            "secret_refs",
9039            "secretRefs",
9040        ];
9041
9042        #[allow(clippy::enum_variant_names)]
9043        enum GeneratedField {
9044            UpstreamSourceId,
9045            RowIdIndex,
9046            Columns,
9047            Info,
9048            SourceName,
9049            WithProperties,
9050            RateLimit,
9051            StateTable,
9052            SecretRefs,
9053        }
9054        impl<'de> serde::Deserialize<'de> for GeneratedField {
9055            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9056            where
9057                D: serde::Deserializer<'de>,
9058            {
9059                struct GeneratedVisitor;
9060
9061                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9062                    type Value = GeneratedField;
9063
9064                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9065                        write!(formatter, "expected one of: {:?}", &FIELDS)
9066                    }
9067
9068                    #[allow(unused_variables)]
9069                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9070                    where
9071                        E: serde::de::Error,
9072                    {
9073                        match value {
9074                            "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
9075                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
9076                            "columns" => Ok(GeneratedField::Columns),
9077                            "info" => Ok(GeneratedField::Info),
9078                            "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
9079                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
9080                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9081                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9082                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9083                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9084                        }
9085                    }
9086                }
9087                deserializer.deserialize_identifier(GeneratedVisitor)
9088            }
9089        }
9090        struct GeneratedVisitor;
9091        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9092            type Value = SourceBackfillNode;
9093
9094            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9095                formatter.write_str("struct stream_plan.SourceBackfillNode")
9096            }
9097
9098            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
9099                where
9100                    V: serde::de::MapAccess<'de>,
9101            {
9102                let mut upstream_source_id__ = None;
9103                let mut row_id_index__ = None;
9104                let mut columns__ = None;
9105                let mut info__ = None;
9106                let mut source_name__ = None;
9107                let mut with_properties__ = None;
9108                let mut rate_limit__ = None;
9109                let mut state_table__ = None;
9110                let mut secret_refs__ = None;
9111                while let Some(k) = map_.next_key()? {
9112                    match k {
9113                        GeneratedField::UpstreamSourceId => {
9114                            if upstream_source_id__.is_some() {
9115                                return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
9116                            }
9117                            upstream_source_id__ = 
9118                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9119                            ;
9120                        }
9121                        GeneratedField::RowIdIndex => {
9122                            if row_id_index__.is_some() {
9123                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9124                            }
9125                            row_id_index__ = 
9126                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9127                            ;
9128                        }
9129                        GeneratedField::Columns => {
9130                            if columns__.is_some() {
9131                                return Err(serde::de::Error::duplicate_field("columns"));
9132                            }
9133                            columns__ = Some(map_.next_value()?);
9134                        }
9135                        GeneratedField::Info => {
9136                            if info__.is_some() {
9137                                return Err(serde::de::Error::duplicate_field("info"));
9138                            }
9139                            info__ = map_.next_value()?;
9140                        }
9141                        GeneratedField::SourceName => {
9142                            if source_name__.is_some() {
9143                                return Err(serde::de::Error::duplicate_field("sourceName"));
9144                            }
9145                            source_name__ = Some(map_.next_value()?);
9146                        }
9147                        GeneratedField::WithProperties => {
9148                            if with_properties__.is_some() {
9149                                return Err(serde::de::Error::duplicate_field("withProperties"));
9150                            }
9151                            with_properties__ = Some(
9152                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
9153                            );
9154                        }
9155                        GeneratedField::RateLimit => {
9156                            if rate_limit__.is_some() {
9157                                return Err(serde::de::Error::duplicate_field("rateLimit"));
9158                            }
9159                            rate_limit__ = 
9160                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9161                            ;
9162                        }
9163                        GeneratedField::StateTable => {
9164                            if state_table__.is_some() {
9165                                return Err(serde::de::Error::duplicate_field("stateTable"));
9166                            }
9167                            state_table__ = map_.next_value()?;
9168                        }
9169                        GeneratedField::SecretRefs => {
9170                            if secret_refs__.is_some() {
9171                                return Err(serde::de::Error::duplicate_field("secretRefs"));
9172                            }
9173                            secret_refs__ = Some(
9174                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
9175                            );
9176                        }
9177                    }
9178                }
9179                Ok(SourceBackfillNode {
9180                    upstream_source_id: upstream_source_id__.unwrap_or_default(),
9181                    row_id_index: row_id_index__,
9182                    columns: columns__.unwrap_or_default(),
9183                    info: info__,
9184                    source_name: source_name__.unwrap_or_default(),
9185                    with_properties: with_properties__.unwrap_or_default(),
9186                    rate_limit: rate_limit__,
9187                    state_table: state_table__,
9188                    secret_refs: secret_refs__.unwrap_or_default(),
9189                })
9190            }
9191        }
9192        deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
9193    }
9194}
9195impl serde::Serialize for SourceChangeSplitMutation {
9196    #[allow(deprecated)]
9197    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9198    where
9199        S: serde::Serializer,
9200    {
9201        use serde::ser::SerializeStruct;
9202        let mut len = 0;
9203        if !self.actor_splits.is_empty() {
9204            len += 1;
9205        }
9206        let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
9207        if !self.actor_splits.is_empty() {
9208            struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
9209        }
9210        struct_ser.end()
9211    }
9212}
9213impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
9214    #[allow(deprecated)]
9215    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9216    where
9217        D: serde::Deserializer<'de>,
9218    {
9219        const FIELDS: &[&str] = &[
9220            "actor_splits",
9221            "actorSplits",
9222        ];
9223
9224        #[allow(clippy::enum_variant_names)]
9225        enum GeneratedField {
9226            ActorSplits,
9227        }
9228        impl<'de> serde::Deserialize<'de> for GeneratedField {
9229            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9230            where
9231                D: serde::Deserializer<'de>,
9232            {
9233                struct GeneratedVisitor;
9234
9235                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9236                    type Value = GeneratedField;
9237
9238                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9239                        write!(formatter, "expected one of: {:?}", &FIELDS)
9240                    }
9241
9242                    #[allow(unused_variables)]
9243                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9244                    where
9245                        E: serde::de::Error,
9246                    {
9247                        match value {
9248                            "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
9249                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9250                        }
9251                    }
9252                }
9253                deserializer.deserialize_identifier(GeneratedVisitor)
9254            }
9255        }
9256        struct GeneratedVisitor;
9257        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9258            type Value = SourceChangeSplitMutation;
9259
9260            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9261                formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
9262            }
9263
9264            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
9265                where
9266                    V: serde::de::MapAccess<'de>,
9267            {
9268                let mut actor_splits__ = None;
9269                while let Some(k) = map_.next_key()? {
9270                    match k {
9271                        GeneratedField::ActorSplits => {
9272                            if actor_splits__.is_some() {
9273                                return Err(serde::de::Error::duplicate_field("actorSplits"));
9274                            }
9275                            actor_splits__ = Some(
9276                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9277                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
9278                            );
9279                        }
9280                    }
9281                }
9282                Ok(SourceChangeSplitMutation {
9283                    actor_splits: actor_splits__.unwrap_or_default(),
9284                })
9285            }
9286        }
9287        deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
9288    }
9289}
9290impl serde::Serialize for SourceNode {
9291    #[allow(deprecated)]
9292    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9293    where
9294        S: serde::Serializer,
9295    {
9296        use serde::ser::SerializeStruct;
9297        let mut len = 0;
9298        if self.source_inner.is_some() {
9299            len += 1;
9300        }
9301        let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
9302        if let Some(v) = self.source_inner.as_ref() {
9303            struct_ser.serialize_field("sourceInner", v)?;
9304        }
9305        struct_ser.end()
9306    }
9307}
9308impl<'de> serde::Deserialize<'de> for SourceNode {
9309    #[allow(deprecated)]
9310    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9311    where
9312        D: serde::Deserializer<'de>,
9313    {
9314        const FIELDS: &[&str] = &[
9315            "source_inner",
9316            "sourceInner",
9317        ];
9318
9319        #[allow(clippy::enum_variant_names)]
9320        enum GeneratedField {
9321            SourceInner,
9322        }
9323        impl<'de> serde::Deserialize<'de> for GeneratedField {
9324            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9325            where
9326                D: serde::Deserializer<'de>,
9327            {
9328                struct GeneratedVisitor;
9329
9330                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9331                    type Value = GeneratedField;
9332
9333                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9334                        write!(formatter, "expected one of: {:?}", &FIELDS)
9335                    }
9336
9337                    #[allow(unused_variables)]
9338                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9339                    where
9340                        E: serde::de::Error,
9341                    {
9342                        match value {
9343                            "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
9344                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9345                        }
9346                    }
9347                }
9348                deserializer.deserialize_identifier(GeneratedVisitor)
9349            }
9350        }
9351        struct GeneratedVisitor;
9352        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9353            type Value = SourceNode;
9354
9355            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9356                formatter.write_str("struct stream_plan.SourceNode")
9357            }
9358
9359            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
9360                where
9361                    V: serde::de::MapAccess<'de>,
9362            {
9363                let mut source_inner__ = None;
9364                while let Some(k) = map_.next_key()? {
9365                    match k {
9366                        GeneratedField::SourceInner => {
9367                            if source_inner__.is_some() {
9368                                return Err(serde::de::Error::duplicate_field("sourceInner"));
9369                            }
9370                            source_inner__ = map_.next_value()?;
9371                        }
9372                    }
9373                }
9374                Ok(SourceNode {
9375                    source_inner: source_inner__,
9376                })
9377            }
9378        }
9379        deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
9380    }
9381}
9382impl serde::Serialize for StartFragmentBackfillMutation {
9383    #[allow(deprecated)]
9384    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9385    where
9386        S: serde::Serializer,
9387    {
9388        use serde::ser::SerializeStruct;
9389        let mut len = 0;
9390        if !self.fragment_ids.is_empty() {
9391            len += 1;
9392        }
9393        let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
9394        if !self.fragment_ids.is_empty() {
9395            struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
9396        }
9397        struct_ser.end()
9398    }
9399}
9400impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
9401    #[allow(deprecated)]
9402    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9403    where
9404        D: serde::Deserializer<'de>,
9405    {
9406        const FIELDS: &[&str] = &[
9407            "fragment_ids",
9408            "fragmentIds",
9409        ];
9410
9411        #[allow(clippy::enum_variant_names)]
9412        enum GeneratedField {
9413            FragmentIds,
9414        }
9415        impl<'de> serde::Deserialize<'de> for GeneratedField {
9416            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9417            where
9418                D: serde::Deserializer<'de>,
9419            {
9420                struct GeneratedVisitor;
9421
9422                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9423                    type Value = GeneratedField;
9424
9425                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9426                        write!(formatter, "expected one of: {:?}", &FIELDS)
9427                    }
9428
9429                    #[allow(unused_variables)]
9430                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9431                    where
9432                        E: serde::de::Error,
9433                    {
9434                        match value {
9435                            "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
9436                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9437                        }
9438                    }
9439                }
9440                deserializer.deserialize_identifier(GeneratedVisitor)
9441            }
9442        }
9443        struct GeneratedVisitor;
9444        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9445            type Value = StartFragmentBackfillMutation;
9446
9447            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9448                formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
9449            }
9450
9451            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
9452                where
9453                    V: serde::de::MapAccess<'de>,
9454            {
9455                let mut fragment_ids__ = None;
9456                while let Some(k) = map_.next_key()? {
9457                    match k {
9458                        GeneratedField::FragmentIds => {
9459                            if fragment_ids__.is_some() {
9460                                return Err(serde::de::Error::duplicate_field("fragmentIds"));
9461                            }
9462                            fragment_ids__ = 
9463                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9464                                    .into_iter().map(|x| x.0).collect())
9465                            ;
9466                        }
9467                    }
9468                }
9469                Ok(StartFragmentBackfillMutation {
9470                    fragment_ids: fragment_ids__.unwrap_or_default(),
9471                })
9472            }
9473        }
9474        deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
9475    }
9476}
9477impl serde::Serialize for StopMutation {
9478    #[allow(deprecated)]
9479    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9480    where
9481        S: serde::Serializer,
9482    {
9483        use serde::ser::SerializeStruct;
9484        let mut len = 0;
9485        if !self.actors.is_empty() {
9486            len += 1;
9487        }
9488        let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
9489        if !self.actors.is_empty() {
9490            struct_ser.serialize_field("actors", &self.actors)?;
9491        }
9492        struct_ser.end()
9493    }
9494}
9495impl<'de> serde::Deserialize<'de> for StopMutation {
9496    #[allow(deprecated)]
9497    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9498    where
9499        D: serde::Deserializer<'de>,
9500    {
9501        const FIELDS: &[&str] = &[
9502            "actors",
9503        ];
9504
9505        #[allow(clippy::enum_variant_names)]
9506        enum GeneratedField {
9507            Actors,
9508        }
9509        impl<'de> serde::Deserialize<'de> for GeneratedField {
9510            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9511            where
9512                D: serde::Deserializer<'de>,
9513            {
9514                struct GeneratedVisitor;
9515
9516                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9517                    type Value = GeneratedField;
9518
9519                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9520                        write!(formatter, "expected one of: {:?}", &FIELDS)
9521                    }
9522
9523                    #[allow(unused_variables)]
9524                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9525                    where
9526                        E: serde::de::Error,
9527                    {
9528                        match value {
9529                            "actors" => Ok(GeneratedField::Actors),
9530                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9531                        }
9532                    }
9533                }
9534                deserializer.deserialize_identifier(GeneratedVisitor)
9535            }
9536        }
9537        struct GeneratedVisitor;
9538        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9539            type Value = StopMutation;
9540
9541            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9542                formatter.write_str("struct stream_plan.StopMutation")
9543            }
9544
9545            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
9546                where
9547                    V: serde::de::MapAccess<'de>,
9548            {
9549                let mut actors__ = None;
9550                while let Some(k) = map_.next_key()? {
9551                    match k {
9552                        GeneratedField::Actors => {
9553                            if actors__.is_some() {
9554                                return Err(serde::de::Error::duplicate_field("actors"));
9555                            }
9556                            actors__ = 
9557                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9558                                    .into_iter().map(|x| x.0).collect())
9559                            ;
9560                        }
9561                    }
9562                }
9563                Ok(StopMutation {
9564                    actors: actors__.unwrap_or_default(),
9565                })
9566            }
9567        }
9568        deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
9569    }
9570}
9571impl serde::Serialize for StreamActor {
9572    #[allow(deprecated)]
9573    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9574    where
9575        S: serde::Serializer,
9576    {
9577        use serde::ser::SerializeStruct;
9578        let mut len = 0;
9579        if self.actor_id != 0 {
9580            len += 1;
9581        }
9582        if self.fragment_id != 0 {
9583            len += 1;
9584        }
9585        if !self.dispatcher.is_empty() {
9586            len += 1;
9587        }
9588        if self.vnode_bitmap.is_some() {
9589            len += 1;
9590        }
9591        if !self.mview_definition.is_empty() {
9592            len += 1;
9593        }
9594        if self.expr_context.is_some() {
9595            len += 1;
9596        }
9597        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
9598        if self.actor_id != 0 {
9599            struct_ser.serialize_field("actorId", &self.actor_id)?;
9600        }
9601        if self.fragment_id != 0 {
9602            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
9603        }
9604        if !self.dispatcher.is_empty() {
9605            struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
9606        }
9607        if let Some(v) = self.vnode_bitmap.as_ref() {
9608            struct_ser.serialize_field("vnodeBitmap", v)?;
9609        }
9610        if !self.mview_definition.is_empty() {
9611            struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
9612        }
9613        if let Some(v) = self.expr_context.as_ref() {
9614            struct_ser.serialize_field("exprContext", v)?;
9615        }
9616        struct_ser.end()
9617    }
9618}
9619impl<'de> serde::Deserialize<'de> for StreamActor {
9620    #[allow(deprecated)]
9621    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9622    where
9623        D: serde::Deserializer<'de>,
9624    {
9625        const FIELDS: &[&str] = &[
9626            "actor_id",
9627            "actorId",
9628            "fragment_id",
9629            "fragmentId",
9630            "dispatcher",
9631            "vnode_bitmap",
9632            "vnodeBitmap",
9633            "mview_definition",
9634            "mviewDefinition",
9635            "expr_context",
9636            "exprContext",
9637        ];
9638
9639        #[allow(clippy::enum_variant_names)]
9640        enum GeneratedField {
9641            ActorId,
9642            FragmentId,
9643            Dispatcher,
9644            VnodeBitmap,
9645            MviewDefinition,
9646            ExprContext,
9647        }
9648        impl<'de> serde::Deserialize<'de> for GeneratedField {
9649            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9650            where
9651                D: serde::Deserializer<'de>,
9652            {
9653                struct GeneratedVisitor;
9654
9655                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9656                    type Value = GeneratedField;
9657
9658                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9659                        write!(formatter, "expected one of: {:?}", &FIELDS)
9660                    }
9661
9662                    #[allow(unused_variables)]
9663                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9664                    where
9665                        E: serde::de::Error,
9666                    {
9667                        match value {
9668                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
9669                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
9670                            "dispatcher" => Ok(GeneratedField::Dispatcher),
9671                            "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
9672                            "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
9673                            "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
9674                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9675                        }
9676                    }
9677                }
9678                deserializer.deserialize_identifier(GeneratedVisitor)
9679            }
9680        }
9681        struct GeneratedVisitor;
9682        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9683            type Value = StreamActor;
9684
9685            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9686                formatter.write_str("struct stream_plan.StreamActor")
9687            }
9688
9689            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
9690                where
9691                    V: serde::de::MapAccess<'de>,
9692            {
9693                let mut actor_id__ = None;
9694                let mut fragment_id__ = None;
9695                let mut dispatcher__ = None;
9696                let mut vnode_bitmap__ = None;
9697                let mut mview_definition__ = None;
9698                let mut expr_context__ = None;
9699                while let Some(k) = map_.next_key()? {
9700                    match k {
9701                        GeneratedField::ActorId => {
9702                            if actor_id__.is_some() {
9703                                return Err(serde::de::Error::duplicate_field("actorId"));
9704                            }
9705                            actor_id__ = 
9706                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9707                            ;
9708                        }
9709                        GeneratedField::FragmentId => {
9710                            if fragment_id__.is_some() {
9711                                return Err(serde::de::Error::duplicate_field("fragmentId"));
9712                            }
9713                            fragment_id__ = 
9714                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9715                            ;
9716                        }
9717                        GeneratedField::Dispatcher => {
9718                            if dispatcher__.is_some() {
9719                                return Err(serde::de::Error::duplicate_field("dispatcher"));
9720                            }
9721                            dispatcher__ = Some(map_.next_value()?);
9722                        }
9723                        GeneratedField::VnodeBitmap => {
9724                            if vnode_bitmap__.is_some() {
9725                                return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
9726                            }
9727                            vnode_bitmap__ = map_.next_value()?;
9728                        }
9729                        GeneratedField::MviewDefinition => {
9730                            if mview_definition__.is_some() {
9731                                return Err(serde::de::Error::duplicate_field("mviewDefinition"));
9732                            }
9733                            mview_definition__ = Some(map_.next_value()?);
9734                        }
9735                        GeneratedField::ExprContext => {
9736                            if expr_context__.is_some() {
9737                                return Err(serde::de::Error::duplicate_field("exprContext"));
9738                            }
9739                            expr_context__ = map_.next_value()?;
9740                        }
9741                    }
9742                }
9743                Ok(StreamActor {
9744                    actor_id: actor_id__.unwrap_or_default(),
9745                    fragment_id: fragment_id__.unwrap_or_default(),
9746                    dispatcher: dispatcher__.unwrap_or_default(),
9747                    vnode_bitmap: vnode_bitmap__,
9748                    mview_definition: mview_definition__.unwrap_or_default(),
9749                    expr_context: expr_context__,
9750                })
9751            }
9752        }
9753        deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
9754    }
9755}
9756impl serde::Serialize for StreamCdcScanNode {
9757    #[allow(deprecated)]
9758    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9759    where
9760        S: serde::Serializer,
9761    {
9762        use serde::ser::SerializeStruct;
9763        let mut len = 0;
9764        if self.table_id != 0 {
9765            len += 1;
9766        }
9767        if !self.upstream_column_ids.is_empty() {
9768            len += 1;
9769        }
9770        if !self.output_indices.is_empty() {
9771            len += 1;
9772        }
9773        if self.state_table.is_some() {
9774            len += 1;
9775        }
9776        if self.cdc_table_desc.is_some() {
9777            len += 1;
9778        }
9779        if self.rate_limit.is_some() {
9780            len += 1;
9781        }
9782        if self.disable_backfill {
9783            len += 1;
9784        }
9785        if self.options.is_some() {
9786            len += 1;
9787        }
9788        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
9789        if self.table_id != 0 {
9790            struct_ser.serialize_field("tableId", &self.table_id)?;
9791        }
9792        if !self.upstream_column_ids.is_empty() {
9793            struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
9794        }
9795        if !self.output_indices.is_empty() {
9796            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
9797        }
9798        if let Some(v) = self.state_table.as_ref() {
9799            struct_ser.serialize_field("stateTable", v)?;
9800        }
9801        if let Some(v) = self.cdc_table_desc.as_ref() {
9802            struct_ser.serialize_field("cdcTableDesc", v)?;
9803        }
9804        if let Some(v) = self.rate_limit.as_ref() {
9805            struct_ser.serialize_field("rateLimit", v)?;
9806        }
9807        if self.disable_backfill {
9808            struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
9809        }
9810        if let Some(v) = self.options.as_ref() {
9811            struct_ser.serialize_field("options", v)?;
9812        }
9813        struct_ser.end()
9814    }
9815}
9816impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
9817    #[allow(deprecated)]
9818    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9819    where
9820        D: serde::Deserializer<'de>,
9821    {
9822        const FIELDS: &[&str] = &[
9823            "table_id",
9824            "tableId",
9825            "upstream_column_ids",
9826            "upstreamColumnIds",
9827            "output_indices",
9828            "outputIndices",
9829            "state_table",
9830            "stateTable",
9831            "cdc_table_desc",
9832            "cdcTableDesc",
9833            "rate_limit",
9834            "rateLimit",
9835            "disable_backfill",
9836            "disableBackfill",
9837            "options",
9838        ];
9839
9840        #[allow(clippy::enum_variant_names)]
9841        enum GeneratedField {
9842            TableId,
9843            UpstreamColumnIds,
9844            OutputIndices,
9845            StateTable,
9846            CdcTableDesc,
9847            RateLimit,
9848            DisableBackfill,
9849            Options,
9850        }
9851        impl<'de> serde::Deserialize<'de> for GeneratedField {
9852            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9853            where
9854                D: serde::Deserializer<'de>,
9855            {
9856                struct GeneratedVisitor;
9857
9858                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9859                    type Value = GeneratedField;
9860
9861                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9862                        write!(formatter, "expected one of: {:?}", &FIELDS)
9863                    }
9864
9865                    #[allow(unused_variables)]
9866                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9867                    where
9868                        E: serde::de::Error,
9869                    {
9870                        match value {
9871                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
9872                            "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
9873                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
9874                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9875                            "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
9876                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9877                            "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
9878                            "options" => Ok(GeneratedField::Options),
9879                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9880                        }
9881                    }
9882                }
9883                deserializer.deserialize_identifier(GeneratedVisitor)
9884            }
9885        }
9886        struct GeneratedVisitor;
9887        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9888            type Value = StreamCdcScanNode;
9889
9890            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9891                formatter.write_str("struct stream_plan.StreamCdcScanNode")
9892            }
9893
9894            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
9895                where
9896                    V: serde::de::MapAccess<'de>,
9897            {
9898                let mut table_id__ = None;
9899                let mut upstream_column_ids__ = None;
9900                let mut output_indices__ = None;
9901                let mut state_table__ = None;
9902                let mut cdc_table_desc__ = None;
9903                let mut rate_limit__ = None;
9904                let mut disable_backfill__ = None;
9905                let mut options__ = None;
9906                while let Some(k) = map_.next_key()? {
9907                    match k {
9908                        GeneratedField::TableId => {
9909                            if table_id__.is_some() {
9910                                return Err(serde::de::Error::duplicate_field("tableId"));
9911                            }
9912                            table_id__ = 
9913                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9914                            ;
9915                        }
9916                        GeneratedField::UpstreamColumnIds => {
9917                            if upstream_column_ids__.is_some() {
9918                                return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
9919                            }
9920                            upstream_column_ids__ = 
9921                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9922                                    .into_iter().map(|x| x.0).collect())
9923                            ;
9924                        }
9925                        GeneratedField::OutputIndices => {
9926                            if output_indices__.is_some() {
9927                                return Err(serde::de::Error::duplicate_field("outputIndices"));
9928                            }
9929                            output_indices__ = 
9930                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9931                                    .into_iter().map(|x| x.0).collect())
9932                            ;
9933                        }
9934                        GeneratedField::StateTable => {
9935                            if state_table__.is_some() {
9936                                return Err(serde::de::Error::duplicate_field("stateTable"));
9937                            }
9938                            state_table__ = map_.next_value()?;
9939                        }
9940                        GeneratedField::CdcTableDesc => {
9941                            if cdc_table_desc__.is_some() {
9942                                return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
9943                            }
9944                            cdc_table_desc__ = map_.next_value()?;
9945                        }
9946                        GeneratedField::RateLimit => {
9947                            if rate_limit__.is_some() {
9948                                return Err(serde::de::Error::duplicate_field("rateLimit"));
9949                            }
9950                            rate_limit__ = 
9951                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9952                            ;
9953                        }
9954                        GeneratedField::DisableBackfill => {
9955                            if disable_backfill__.is_some() {
9956                                return Err(serde::de::Error::duplicate_field("disableBackfill"));
9957                            }
9958                            disable_backfill__ = Some(map_.next_value()?);
9959                        }
9960                        GeneratedField::Options => {
9961                            if options__.is_some() {
9962                                return Err(serde::de::Error::duplicate_field("options"));
9963                            }
9964                            options__ = map_.next_value()?;
9965                        }
9966                    }
9967                }
9968                Ok(StreamCdcScanNode {
9969                    table_id: table_id__.unwrap_or_default(),
9970                    upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
9971                    output_indices: output_indices__.unwrap_or_default(),
9972                    state_table: state_table__,
9973                    cdc_table_desc: cdc_table_desc__,
9974                    rate_limit: rate_limit__,
9975                    disable_backfill: disable_backfill__.unwrap_or_default(),
9976                    options: options__,
9977                })
9978            }
9979        }
9980        deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
9981    }
9982}
9983impl serde::Serialize for StreamCdcScanOptions {
9984    #[allow(deprecated)]
9985    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9986    where
9987        S: serde::Serializer,
9988    {
9989        use serde::ser::SerializeStruct;
9990        let mut len = 0;
9991        if self.disable_backfill {
9992            len += 1;
9993        }
9994        if self.snapshot_barrier_interval != 0 {
9995            len += 1;
9996        }
9997        if self.snapshot_batch_size != 0 {
9998            len += 1;
9999        }
10000        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
10001        if self.disable_backfill {
10002            struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
10003        }
10004        if self.snapshot_barrier_interval != 0 {
10005            struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
10006        }
10007        if self.snapshot_batch_size != 0 {
10008            struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
10009        }
10010        struct_ser.end()
10011    }
10012}
10013impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
10014    #[allow(deprecated)]
10015    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10016    where
10017        D: serde::Deserializer<'de>,
10018    {
10019        const FIELDS: &[&str] = &[
10020            "disable_backfill",
10021            "disableBackfill",
10022            "snapshot_barrier_interval",
10023            "snapshotBarrierInterval",
10024            "snapshot_batch_size",
10025            "snapshotBatchSize",
10026        ];
10027
10028        #[allow(clippy::enum_variant_names)]
10029        enum GeneratedField {
10030            DisableBackfill,
10031            SnapshotBarrierInterval,
10032            SnapshotBatchSize,
10033        }
10034        impl<'de> serde::Deserialize<'de> for GeneratedField {
10035            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10036            where
10037                D: serde::Deserializer<'de>,
10038            {
10039                struct GeneratedVisitor;
10040
10041                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10042                    type Value = GeneratedField;
10043
10044                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10045                        write!(formatter, "expected one of: {:?}", &FIELDS)
10046                    }
10047
10048                    #[allow(unused_variables)]
10049                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10050                    where
10051                        E: serde::de::Error,
10052                    {
10053                        match value {
10054                            "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
10055                            "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
10056                            "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
10057                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10058                        }
10059                    }
10060                }
10061                deserializer.deserialize_identifier(GeneratedVisitor)
10062            }
10063        }
10064        struct GeneratedVisitor;
10065        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10066            type Value = StreamCdcScanOptions;
10067
10068            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10069                formatter.write_str("struct stream_plan.StreamCdcScanOptions")
10070            }
10071
10072            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
10073                where
10074                    V: serde::de::MapAccess<'de>,
10075            {
10076                let mut disable_backfill__ = None;
10077                let mut snapshot_barrier_interval__ = None;
10078                let mut snapshot_batch_size__ = None;
10079                while let Some(k) = map_.next_key()? {
10080                    match k {
10081                        GeneratedField::DisableBackfill => {
10082                            if disable_backfill__.is_some() {
10083                                return Err(serde::de::Error::duplicate_field("disableBackfill"));
10084                            }
10085                            disable_backfill__ = Some(map_.next_value()?);
10086                        }
10087                        GeneratedField::SnapshotBarrierInterval => {
10088                            if snapshot_barrier_interval__.is_some() {
10089                                return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
10090                            }
10091                            snapshot_barrier_interval__ = 
10092                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10093                            ;
10094                        }
10095                        GeneratedField::SnapshotBatchSize => {
10096                            if snapshot_batch_size__.is_some() {
10097                                return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
10098                            }
10099                            snapshot_batch_size__ = 
10100                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10101                            ;
10102                        }
10103                    }
10104                }
10105                Ok(StreamCdcScanOptions {
10106                    disable_backfill: disable_backfill__.unwrap_or_default(),
10107                    snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
10108                    snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
10109                })
10110            }
10111        }
10112        deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
10113    }
10114}
10115impl serde::Serialize for StreamContext {
10116    #[allow(deprecated)]
10117    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10118    where
10119        S: serde::Serializer,
10120    {
10121        use serde::ser::SerializeStruct;
10122        let mut len = 0;
10123        if !self.timezone.is_empty() {
10124            len += 1;
10125        }
10126        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
10127        if !self.timezone.is_empty() {
10128            struct_ser.serialize_field("timezone", &self.timezone)?;
10129        }
10130        struct_ser.end()
10131    }
10132}
10133impl<'de> serde::Deserialize<'de> for StreamContext {
10134    #[allow(deprecated)]
10135    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10136    where
10137        D: serde::Deserializer<'de>,
10138    {
10139        const FIELDS: &[&str] = &[
10140            "timezone",
10141        ];
10142
10143        #[allow(clippy::enum_variant_names)]
10144        enum GeneratedField {
10145            Timezone,
10146        }
10147        impl<'de> serde::Deserialize<'de> for GeneratedField {
10148            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10149            where
10150                D: serde::Deserializer<'de>,
10151            {
10152                struct GeneratedVisitor;
10153
10154                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10155                    type Value = GeneratedField;
10156
10157                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10158                        write!(formatter, "expected one of: {:?}", &FIELDS)
10159                    }
10160
10161                    #[allow(unused_variables)]
10162                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10163                    where
10164                        E: serde::de::Error,
10165                    {
10166                        match value {
10167                            "timezone" => Ok(GeneratedField::Timezone),
10168                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10169                        }
10170                    }
10171                }
10172                deserializer.deserialize_identifier(GeneratedVisitor)
10173            }
10174        }
10175        struct GeneratedVisitor;
10176        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10177            type Value = StreamContext;
10178
10179            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10180                formatter.write_str("struct stream_plan.StreamContext")
10181            }
10182
10183            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
10184                where
10185                    V: serde::de::MapAccess<'de>,
10186            {
10187                let mut timezone__ = None;
10188                while let Some(k) = map_.next_key()? {
10189                    match k {
10190                        GeneratedField::Timezone => {
10191                            if timezone__.is_some() {
10192                                return Err(serde::de::Error::duplicate_field("timezone"));
10193                            }
10194                            timezone__ = Some(map_.next_value()?);
10195                        }
10196                    }
10197                }
10198                Ok(StreamContext {
10199                    timezone: timezone__.unwrap_or_default(),
10200                })
10201            }
10202        }
10203        deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
10204    }
10205}
10206impl serde::Serialize for StreamFragmentGraph {
10207    #[allow(deprecated)]
10208    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10209    where
10210        S: serde::Serializer,
10211    {
10212        use serde::ser::SerializeStruct;
10213        let mut len = 0;
10214        if !self.fragments.is_empty() {
10215            len += 1;
10216        }
10217        if !self.edges.is_empty() {
10218            len += 1;
10219        }
10220        if !self.dependent_table_ids.is_empty() {
10221            len += 1;
10222        }
10223        if self.table_ids_cnt != 0 {
10224            len += 1;
10225        }
10226        if self.ctx.is_some() {
10227            len += 1;
10228        }
10229        if self.parallelism.is_some() {
10230            len += 1;
10231        }
10232        if self.max_parallelism != 0 {
10233            len += 1;
10234        }
10235        if self.backfill_order.is_some() {
10236            len += 1;
10237        }
10238        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
10239        if !self.fragments.is_empty() {
10240            struct_ser.serialize_field("fragments", &self.fragments)?;
10241        }
10242        if !self.edges.is_empty() {
10243            struct_ser.serialize_field("edges", &self.edges)?;
10244        }
10245        if !self.dependent_table_ids.is_empty() {
10246            struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
10247        }
10248        if self.table_ids_cnt != 0 {
10249            struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
10250        }
10251        if let Some(v) = self.ctx.as_ref() {
10252            struct_ser.serialize_field("ctx", v)?;
10253        }
10254        if let Some(v) = self.parallelism.as_ref() {
10255            struct_ser.serialize_field("parallelism", v)?;
10256        }
10257        if self.max_parallelism != 0 {
10258            struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10259        }
10260        if let Some(v) = self.backfill_order.as_ref() {
10261            struct_ser.serialize_field("backfillOrder", v)?;
10262        }
10263        struct_ser.end()
10264    }
10265}
10266impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
10267    #[allow(deprecated)]
10268    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10269    where
10270        D: serde::Deserializer<'de>,
10271    {
10272        const FIELDS: &[&str] = &[
10273            "fragments",
10274            "edges",
10275            "dependent_table_ids",
10276            "dependentTableIds",
10277            "table_ids_cnt",
10278            "tableIdsCnt",
10279            "ctx",
10280            "parallelism",
10281            "max_parallelism",
10282            "maxParallelism",
10283            "backfill_order",
10284            "backfillOrder",
10285        ];
10286
10287        #[allow(clippy::enum_variant_names)]
10288        enum GeneratedField {
10289            Fragments,
10290            Edges,
10291            DependentTableIds,
10292            TableIdsCnt,
10293            Ctx,
10294            Parallelism,
10295            MaxParallelism,
10296            BackfillOrder,
10297        }
10298        impl<'de> serde::Deserialize<'de> for GeneratedField {
10299            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10300            where
10301                D: serde::Deserializer<'de>,
10302            {
10303                struct GeneratedVisitor;
10304
10305                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10306                    type Value = GeneratedField;
10307
10308                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10309                        write!(formatter, "expected one of: {:?}", &FIELDS)
10310                    }
10311
10312                    #[allow(unused_variables)]
10313                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10314                    where
10315                        E: serde::de::Error,
10316                    {
10317                        match value {
10318                            "fragments" => Ok(GeneratedField::Fragments),
10319                            "edges" => Ok(GeneratedField::Edges),
10320                            "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
10321                            "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
10322                            "ctx" => Ok(GeneratedField::Ctx),
10323                            "parallelism" => Ok(GeneratedField::Parallelism),
10324                            "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
10325                            "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
10326                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10327                        }
10328                    }
10329                }
10330                deserializer.deserialize_identifier(GeneratedVisitor)
10331            }
10332        }
10333        struct GeneratedVisitor;
10334        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10335            type Value = StreamFragmentGraph;
10336
10337            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10338                formatter.write_str("struct stream_plan.StreamFragmentGraph")
10339            }
10340
10341            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
10342                where
10343                    V: serde::de::MapAccess<'de>,
10344            {
10345                let mut fragments__ = None;
10346                let mut edges__ = None;
10347                let mut dependent_table_ids__ = None;
10348                let mut table_ids_cnt__ = None;
10349                let mut ctx__ = None;
10350                let mut parallelism__ = None;
10351                let mut max_parallelism__ = None;
10352                let mut backfill_order__ = None;
10353                while let Some(k) = map_.next_key()? {
10354                    match k {
10355                        GeneratedField::Fragments => {
10356                            if fragments__.is_some() {
10357                                return Err(serde::de::Error::duplicate_field("fragments"));
10358                            }
10359                            fragments__ = Some(
10360                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
10361                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
10362                            );
10363                        }
10364                        GeneratedField::Edges => {
10365                            if edges__.is_some() {
10366                                return Err(serde::de::Error::duplicate_field("edges"));
10367                            }
10368                            edges__ = Some(map_.next_value()?);
10369                        }
10370                        GeneratedField::DependentTableIds => {
10371                            if dependent_table_ids__.is_some() {
10372                                return Err(serde::de::Error::duplicate_field("dependentTableIds"));
10373                            }
10374                            dependent_table_ids__ = 
10375                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10376                                    .into_iter().map(|x| x.0).collect())
10377                            ;
10378                        }
10379                        GeneratedField::TableIdsCnt => {
10380                            if table_ids_cnt__.is_some() {
10381                                return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
10382                            }
10383                            table_ids_cnt__ = 
10384                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10385                            ;
10386                        }
10387                        GeneratedField::Ctx => {
10388                            if ctx__.is_some() {
10389                                return Err(serde::de::Error::duplicate_field("ctx"));
10390                            }
10391                            ctx__ = map_.next_value()?;
10392                        }
10393                        GeneratedField::Parallelism => {
10394                            if parallelism__.is_some() {
10395                                return Err(serde::de::Error::duplicate_field("parallelism"));
10396                            }
10397                            parallelism__ = map_.next_value()?;
10398                        }
10399                        GeneratedField::MaxParallelism => {
10400                            if max_parallelism__.is_some() {
10401                                return Err(serde::de::Error::duplicate_field("maxParallelism"));
10402                            }
10403                            max_parallelism__ = 
10404                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10405                            ;
10406                        }
10407                        GeneratedField::BackfillOrder => {
10408                            if backfill_order__.is_some() {
10409                                return Err(serde::de::Error::duplicate_field("backfillOrder"));
10410                            }
10411                            backfill_order__ = map_.next_value()?;
10412                        }
10413                    }
10414                }
10415                Ok(StreamFragmentGraph {
10416                    fragments: fragments__.unwrap_or_default(),
10417                    edges: edges__.unwrap_or_default(),
10418                    dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
10419                    table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
10420                    ctx: ctx__,
10421                    parallelism: parallelism__,
10422                    max_parallelism: max_parallelism__.unwrap_or_default(),
10423                    backfill_order: backfill_order__,
10424                })
10425            }
10426        }
10427        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
10428    }
10429}
10430impl serde::Serialize for stream_fragment_graph::Parallelism {
10431    #[allow(deprecated)]
10432    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10433    where
10434        S: serde::Serializer,
10435    {
10436        use serde::ser::SerializeStruct;
10437        let mut len = 0;
10438        if self.parallelism != 0 {
10439            len += 1;
10440        }
10441        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
10442        if self.parallelism != 0 {
10443            #[allow(clippy::needless_borrow)]
10444            #[allow(clippy::needless_borrows_for_generic_args)]
10445            struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
10446        }
10447        struct_ser.end()
10448    }
10449}
10450impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
10451    #[allow(deprecated)]
10452    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10453    where
10454        D: serde::Deserializer<'de>,
10455    {
10456        const FIELDS: &[&str] = &[
10457            "parallelism",
10458        ];
10459
10460        #[allow(clippy::enum_variant_names)]
10461        enum GeneratedField {
10462            Parallelism,
10463        }
10464        impl<'de> serde::Deserialize<'de> for GeneratedField {
10465            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10466            where
10467                D: serde::Deserializer<'de>,
10468            {
10469                struct GeneratedVisitor;
10470
10471                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10472                    type Value = GeneratedField;
10473
10474                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10475                        write!(formatter, "expected one of: {:?}", &FIELDS)
10476                    }
10477
10478                    #[allow(unused_variables)]
10479                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10480                    where
10481                        E: serde::de::Error,
10482                    {
10483                        match value {
10484                            "parallelism" => Ok(GeneratedField::Parallelism),
10485                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10486                        }
10487                    }
10488                }
10489                deserializer.deserialize_identifier(GeneratedVisitor)
10490            }
10491        }
10492        struct GeneratedVisitor;
10493        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10494            type Value = stream_fragment_graph::Parallelism;
10495
10496            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10497                formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
10498            }
10499
10500            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
10501                where
10502                    V: serde::de::MapAccess<'de>,
10503            {
10504                let mut parallelism__ = None;
10505                while let Some(k) = map_.next_key()? {
10506                    match k {
10507                        GeneratedField::Parallelism => {
10508                            if parallelism__.is_some() {
10509                                return Err(serde::de::Error::duplicate_field("parallelism"));
10510                            }
10511                            parallelism__ = 
10512                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10513                            ;
10514                        }
10515                    }
10516                }
10517                Ok(stream_fragment_graph::Parallelism {
10518                    parallelism: parallelism__.unwrap_or_default(),
10519                })
10520            }
10521        }
10522        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
10523    }
10524}
10525impl serde::Serialize for stream_fragment_graph::StreamFragment {
10526    #[allow(deprecated)]
10527    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10528    where
10529        S: serde::Serializer,
10530    {
10531        use serde::ser::SerializeStruct;
10532        let mut len = 0;
10533        if self.fragment_id != 0 {
10534            len += 1;
10535        }
10536        if self.node.is_some() {
10537            len += 1;
10538        }
10539        if self.fragment_type_mask != 0 {
10540            len += 1;
10541        }
10542        if self.requires_singleton {
10543            len += 1;
10544        }
10545        if self.table_ids_cnt != 0 {
10546            len += 1;
10547        }
10548        if !self.upstream_table_ids.is_empty() {
10549            len += 1;
10550        }
10551        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
10552        if self.fragment_id != 0 {
10553            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10554        }
10555        if let Some(v) = self.node.as_ref() {
10556            struct_ser.serialize_field("node", v)?;
10557        }
10558        if self.fragment_type_mask != 0 {
10559            struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
10560        }
10561        if self.requires_singleton {
10562            struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
10563        }
10564        if self.table_ids_cnt != 0 {
10565            struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
10566        }
10567        if !self.upstream_table_ids.is_empty() {
10568            struct_ser.serialize_field("upstreamTableIds", &self.upstream_table_ids)?;
10569        }
10570        struct_ser.end()
10571    }
10572}
10573impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
10574    #[allow(deprecated)]
10575    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10576    where
10577        D: serde::Deserializer<'de>,
10578    {
10579        const FIELDS: &[&str] = &[
10580            "fragment_id",
10581            "fragmentId",
10582            "node",
10583            "fragment_type_mask",
10584            "fragmentTypeMask",
10585            "requires_singleton",
10586            "requiresSingleton",
10587            "table_ids_cnt",
10588            "tableIdsCnt",
10589            "upstream_table_ids",
10590            "upstreamTableIds",
10591        ];
10592
10593        #[allow(clippy::enum_variant_names)]
10594        enum GeneratedField {
10595            FragmentId,
10596            Node,
10597            FragmentTypeMask,
10598            RequiresSingleton,
10599            TableIdsCnt,
10600            UpstreamTableIds,
10601        }
10602        impl<'de> serde::Deserialize<'de> for GeneratedField {
10603            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10604            where
10605                D: serde::Deserializer<'de>,
10606            {
10607                struct GeneratedVisitor;
10608
10609                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10610                    type Value = GeneratedField;
10611
10612                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10613                        write!(formatter, "expected one of: {:?}", &FIELDS)
10614                    }
10615
10616                    #[allow(unused_variables)]
10617                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10618                    where
10619                        E: serde::de::Error,
10620                    {
10621                        match value {
10622                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10623                            "node" => Ok(GeneratedField::Node),
10624                            "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
10625                            "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
10626                            "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
10627                            "upstreamTableIds" | "upstream_table_ids" => Ok(GeneratedField::UpstreamTableIds),
10628                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10629                        }
10630                    }
10631                }
10632                deserializer.deserialize_identifier(GeneratedVisitor)
10633            }
10634        }
10635        struct GeneratedVisitor;
10636        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10637            type Value = stream_fragment_graph::StreamFragment;
10638
10639            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10640                formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
10641            }
10642
10643            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
10644                where
10645                    V: serde::de::MapAccess<'de>,
10646            {
10647                let mut fragment_id__ = None;
10648                let mut node__ = None;
10649                let mut fragment_type_mask__ = None;
10650                let mut requires_singleton__ = None;
10651                let mut table_ids_cnt__ = None;
10652                let mut upstream_table_ids__ = None;
10653                while let Some(k) = map_.next_key()? {
10654                    match k {
10655                        GeneratedField::FragmentId => {
10656                            if fragment_id__.is_some() {
10657                                return Err(serde::de::Error::duplicate_field("fragmentId"));
10658                            }
10659                            fragment_id__ = 
10660                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10661                            ;
10662                        }
10663                        GeneratedField::Node => {
10664                            if node__.is_some() {
10665                                return Err(serde::de::Error::duplicate_field("node"));
10666                            }
10667                            node__ = map_.next_value()?;
10668                        }
10669                        GeneratedField::FragmentTypeMask => {
10670                            if fragment_type_mask__.is_some() {
10671                                return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
10672                            }
10673                            fragment_type_mask__ = 
10674                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10675                            ;
10676                        }
10677                        GeneratedField::RequiresSingleton => {
10678                            if requires_singleton__.is_some() {
10679                                return Err(serde::de::Error::duplicate_field("requiresSingleton"));
10680                            }
10681                            requires_singleton__ = Some(map_.next_value()?);
10682                        }
10683                        GeneratedField::TableIdsCnt => {
10684                            if table_ids_cnt__.is_some() {
10685                                return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
10686                            }
10687                            table_ids_cnt__ = 
10688                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10689                            ;
10690                        }
10691                        GeneratedField::UpstreamTableIds => {
10692                            if upstream_table_ids__.is_some() {
10693                                return Err(serde::de::Error::duplicate_field("upstreamTableIds"));
10694                            }
10695                            upstream_table_ids__ = 
10696                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10697                                    .into_iter().map(|x| x.0).collect())
10698                            ;
10699                        }
10700                    }
10701                }
10702                Ok(stream_fragment_graph::StreamFragment {
10703                    fragment_id: fragment_id__.unwrap_or_default(),
10704                    node: node__,
10705                    fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
10706                    requires_singleton: requires_singleton__.unwrap_or_default(),
10707                    table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
10708                    upstream_table_ids: upstream_table_ids__.unwrap_or_default(),
10709                })
10710            }
10711        }
10712        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
10713    }
10714}
10715impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
10716    #[allow(deprecated)]
10717    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10718    where
10719        S: serde::Serializer,
10720    {
10721        use serde::ser::SerializeStruct;
10722        let mut len = 0;
10723        if self.dispatch_strategy.is_some() {
10724            len += 1;
10725        }
10726        if self.link_id != 0 {
10727            len += 1;
10728        }
10729        if self.upstream_id != 0 {
10730            len += 1;
10731        }
10732        if self.downstream_id != 0 {
10733            len += 1;
10734        }
10735        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
10736        if let Some(v) = self.dispatch_strategy.as_ref() {
10737            struct_ser.serialize_field("dispatchStrategy", v)?;
10738        }
10739        if self.link_id != 0 {
10740            #[allow(clippy::needless_borrow)]
10741            #[allow(clippy::needless_borrows_for_generic_args)]
10742            struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
10743        }
10744        if self.upstream_id != 0 {
10745            struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
10746        }
10747        if self.downstream_id != 0 {
10748            struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
10749        }
10750        struct_ser.end()
10751    }
10752}
10753impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
10754    #[allow(deprecated)]
10755    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10756    where
10757        D: serde::Deserializer<'de>,
10758    {
10759        const FIELDS: &[&str] = &[
10760            "dispatch_strategy",
10761            "dispatchStrategy",
10762            "link_id",
10763            "linkId",
10764            "upstream_id",
10765            "upstreamId",
10766            "downstream_id",
10767            "downstreamId",
10768        ];
10769
10770        #[allow(clippy::enum_variant_names)]
10771        enum GeneratedField {
10772            DispatchStrategy,
10773            LinkId,
10774            UpstreamId,
10775            DownstreamId,
10776        }
10777        impl<'de> serde::Deserialize<'de> for GeneratedField {
10778            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10779            where
10780                D: serde::Deserializer<'de>,
10781            {
10782                struct GeneratedVisitor;
10783
10784                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10785                    type Value = GeneratedField;
10786
10787                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10788                        write!(formatter, "expected one of: {:?}", &FIELDS)
10789                    }
10790
10791                    #[allow(unused_variables)]
10792                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10793                    where
10794                        E: serde::de::Error,
10795                    {
10796                        match value {
10797                            "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
10798                            "linkId" | "link_id" => Ok(GeneratedField::LinkId),
10799                            "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
10800                            "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
10801                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10802                        }
10803                    }
10804                }
10805                deserializer.deserialize_identifier(GeneratedVisitor)
10806            }
10807        }
10808        struct GeneratedVisitor;
10809        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10810            type Value = stream_fragment_graph::StreamFragmentEdge;
10811
10812            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10813                formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
10814            }
10815
10816            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
10817                where
10818                    V: serde::de::MapAccess<'de>,
10819            {
10820                let mut dispatch_strategy__ = None;
10821                let mut link_id__ = None;
10822                let mut upstream_id__ = None;
10823                let mut downstream_id__ = None;
10824                while let Some(k) = map_.next_key()? {
10825                    match k {
10826                        GeneratedField::DispatchStrategy => {
10827                            if dispatch_strategy__.is_some() {
10828                                return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
10829                            }
10830                            dispatch_strategy__ = map_.next_value()?;
10831                        }
10832                        GeneratedField::LinkId => {
10833                            if link_id__.is_some() {
10834                                return Err(serde::de::Error::duplicate_field("linkId"));
10835                            }
10836                            link_id__ = 
10837                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10838                            ;
10839                        }
10840                        GeneratedField::UpstreamId => {
10841                            if upstream_id__.is_some() {
10842                                return Err(serde::de::Error::duplicate_field("upstreamId"));
10843                            }
10844                            upstream_id__ = 
10845                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10846                            ;
10847                        }
10848                        GeneratedField::DownstreamId => {
10849                            if downstream_id__.is_some() {
10850                                return Err(serde::de::Error::duplicate_field("downstreamId"));
10851                            }
10852                            downstream_id__ = 
10853                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10854                            ;
10855                        }
10856                    }
10857                }
10858                Ok(stream_fragment_graph::StreamFragmentEdge {
10859                    dispatch_strategy: dispatch_strategy__,
10860                    link_id: link_id__.unwrap_or_default(),
10861                    upstream_id: upstream_id__.unwrap_or_default(),
10862                    downstream_id: downstream_id__.unwrap_or_default(),
10863                })
10864            }
10865        }
10866        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
10867    }
10868}
10869impl serde::Serialize for StreamFsFetch {
10870    #[allow(deprecated)]
10871    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10872    where
10873        S: serde::Serializer,
10874    {
10875        use serde::ser::SerializeStruct;
10876        let mut len = 0;
10877        if self.source_id != 0 {
10878            len += 1;
10879        }
10880        if self.state_table.is_some() {
10881            len += 1;
10882        }
10883        if self.row_id_index.is_some() {
10884            len += 1;
10885        }
10886        if !self.columns.is_empty() {
10887            len += 1;
10888        }
10889        if !self.with_properties.is_empty() {
10890            len += 1;
10891        }
10892        if self.info.is_some() {
10893            len += 1;
10894        }
10895        if !self.source_name.is_empty() {
10896            len += 1;
10897        }
10898        if self.rate_limit.is_some() {
10899            len += 1;
10900        }
10901        if !self.secret_refs.is_empty() {
10902            len += 1;
10903        }
10904        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
10905        if self.source_id != 0 {
10906            struct_ser.serialize_field("sourceId", &self.source_id)?;
10907        }
10908        if let Some(v) = self.state_table.as_ref() {
10909            struct_ser.serialize_field("stateTable", v)?;
10910        }
10911        if let Some(v) = self.row_id_index.as_ref() {
10912            struct_ser.serialize_field("rowIdIndex", v)?;
10913        }
10914        if !self.columns.is_empty() {
10915            struct_ser.serialize_field("columns", &self.columns)?;
10916        }
10917        if !self.with_properties.is_empty() {
10918            struct_ser.serialize_field("withProperties", &self.with_properties)?;
10919        }
10920        if let Some(v) = self.info.as_ref() {
10921            struct_ser.serialize_field("info", v)?;
10922        }
10923        if !self.source_name.is_empty() {
10924            struct_ser.serialize_field("sourceName", &self.source_name)?;
10925        }
10926        if let Some(v) = self.rate_limit.as_ref() {
10927            struct_ser.serialize_field("rateLimit", v)?;
10928        }
10929        if !self.secret_refs.is_empty() {
10930            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
10931        }
10932        struct_ser.end()
10933    }
10934}
10935impl<'de> serde::Deserialize<'de> for StreamFsFetch {
10936    #[allow(deprecated)]
10937    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10938    where
10939        D: serde::Deserializer<'de>,
10940    {
10941        const FIELDS: &[&str] = &[
10942            "source_id",
10943            "sourceId",
10944            "state_table",
10945            "stateTable",
10946            "row_id_index",
10947            "rowIdIndex",
10948            "columns",
10949            "with_properties",
10950            "withProperties",
10951            "info",
10952            "source_name",
10953            "sourceName",
10954            "rate_limit",
10955            "rateLimit",
10956            "secret_refs",
10957            "secretRefs",
10958        ];
10959
10960        #[allow(clippy::enum_variant_names)]
10961        enum GeneratedField {
10962            SourceId,
10963            StateTable,
10964            RowIdIndex,
10965            Columns,
10966            WithProperties,
10967            Info,
10968            SourceName,
10969            RateLimit,
10970            SecretRefs,
10971        }
10972        impl<'de> serde::Deserialize<'de> for GeneratedField {
10973            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10974            where
10975                D: serde::Deserializer<'de>,
10976            {
10977                struct GeneratedVisitor;
10978
10979                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10980                    type Value = GeneratedField;
10981
10982                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10983                        write!(formatter, "expected one of: {:?}", &FIELDS)
10984                    }
10985
10986                    #[allow(unused_variables)]
10987                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10988                    where
10989                        E: serde::de::Error,
10990                    {
10991                        match value {
10992                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
10993                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10994                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
10995                            "columns" => Ok(GeneratedField::Columns),
10996                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
10997                            "info" => Ok(GeneratedField::Info),
10998                            "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
10999                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11000                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
11001                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11002                        }
11003                    }
11004                }
11005                deserializer.deserialize_identifier(GeneratedVisitor)
11006            }
11007        }
11008        struct GeneratedVisitor;
11009        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11010            type Value = StreamFsFetch;
11011
11012            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11013                formatter.write_str("struct stream_plan.StreamFsFetch")
11014            }
11015
11016            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
11017                where
11018                    V: serde::de::MapAccess<'de>,
11019            {
11020                let mut source_id__ = None;
11021                let mut state_table__ = None;
11022                let mut row_id_index__ = None;
11023                let mut columns__ = None;
11024                let mut with_properties__ = None;
11025                let mut info__ = None;
11026                let mut source_name__ = None;
11027                let mut rate_limit__ = None;
11028                let mut secret_refs__ = None;
11029                while let Some(k) = map_.next_key()? {
11030                    match k {
11031                        GeneratedField::SourceId => {
11032                            if source_id__.is_some() {
11033                                return Err(serde::de::Error::duplicate_field("sourceId"));
11034                            }
11035                            source_id__ = 
11036                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11037                            ;
11038                        }
11039                        GeneratedField::StateTable => {
11040                            if state_table__.is_some() {
11041                                return Err(serde::de::Error::duplicate_field("stateTable"));
11042                            }
11043                            state_table__ = map_.next_value()?;
11044                        }
11045                        GeneratedField::RowIdIndex => {
11046                            if row_id_index__.is_some() {
11047                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
11048                            }
11049                            row_id_index__ = 
11050                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11051                            ;
11052                        }
11053                        GeneratedField::Columns => {
11054                            if columns__.is_some() {
11055                                return Err(serde::de::Error::duplicate_field("columns"));
11056                            }
11057                            columns__ = Some(map_.next_value()?);
11058                        }
11059                        GeneratedField::WithProperties => {
11060                            if with_properties__.is_some() {
11061                                return Err(serde::de::Error::duplicate_field("withProperties"));
11062                            }
11063                            with_properties__ = Some(
11064                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
11065                            );
11066                        }
11067                        GeneratedField::Info => {
11068                            if info__.is_some() {
11069                                return Err(serde::de::Error::duplicate_field("info"));
11070                            }
11071                            info__ = map_.next_value()?;
11072                        }
11073                        GeneratedField::SourceName => {
11074                            if source_name__.is_some() {
11075                                return Err(serde::de::Error::duplicate_field("sourceName"));
11076                            }
11077                            source_name__ = Some(map_.next_value()?);
11078                        }
11079                        GeneratedField::RateLimit => {
11080                            if rate_limit__.is_some() {
11081                                return Err(serde::de::Error::duplicate_field("rateLimit"));
11082                            }
11083                            rate_limit__ = 
11084                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11085                            ;
11086                        }
11087                        GeneratedField::SecretRefs => {
11088                            if secret_refs__.is_some() {
11089                                return Err(serde::de::Error::duplicate_field("secretRefs"));
11090                            }
11091                            secret_refs__ = Some(
11092                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
11093                            );
11094                        }
11095                    }
11096                }
11097                Ok(StreamFsFetch {
11098                    source_id: source_id__.unwrap_or_default(),
11099                    state_table: state_table__,
11100                    row_id_index: row_id_index__,
11101                    columns: columns__.unwrap_or_default(),
11102                    with_properties: with_properties__.unwrap_or_default(),
11103                    info: info__,
11104                    source_name: source_name__.unwrap_or_default(),
11105                    rate_limit: rate_limit__,
11106                    secret_refs: secret_refs__.unwrap_or_default(),
11107                })
11108            }
11109        }
11110        deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
11111    }
11112}
11113impl serde::Serialize for StreamFsFetchNode {
11114    #[allow(deprecated)]
11115    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11116    where
11117        S: serde::Serializer,
11118    {
11119        use serde::ser::SerializeStruct;
11120        let mut len = 0;
11121        if self.node_inner.is_some() {
11122            len += 1;
11123        }
11124        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
11125        if let Some(v) = self.node_inner.as_ref() {
11126            struct_ser.serialize_field("nodeInner", v)?;
11127        }
11128        struct_ser.end()
11129    }
11130}
11131impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
11132    #[allow(deprecated)]
11133    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11134    where
11135        D: serde::Deserializer<'de>,
11136    {
11137        const FIELDS: &[&str] = &[
11138            "node_inner",
11139            "nodeInner",
11140        ];
11141
11142        #[allow(clippy::enum_variant_names)]
11143        enum GeneratedField {
11144            NodeInner,
11145        }
11146        impl<'de> serde::Deserialize<'de> for GeneratedField {
11147            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11148            where
11149                D: serde::Deserializer<'de>,
11150            {
11151                struct GeneratedVisitor;
11152
11153                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11154                    type Value = GeneratedField;
11155
11156                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11157                        write!(formatter, "expected one of: {:?}", &FIELDS)
11158                    }
11159
11160                    #[allow(unused_variables)]
11161                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11162                    where
11163                        E: serde::de::Error,
11164                    {
11165                        match value {
11166                            "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
11167                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11168                        }
11169                    }
11170                }
11171                deserializer.deserialize_identifier(GeneratedVisitor)
11172            }
11173        }
11174        struct GeneratedVisitor;
11175        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11176            type Value = StreamFsFetchNode;
11177
11178            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11179                formatter.write_str("struct stream_plan.StreamFsFetchNode")
11180            }
11181
11182            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
11183                where
11184                    V: serde::de::MapAccess<'de>,
11185            {
11186                let mut node_inner__ = None;
11187                while let Some(k) = map_.next_key()? {
11188                    match k {
11189                        GeneratedField::NodeInner => {
11190                            if node_inner__.is_some() {
11191                                return Err(serde::de::Error::duplicate_field("nodeInner"));
11192                            }
11193                            node_inner__ = map_.next_value()?;
11194                        }
11195                    }
11196                }
11197                Ok(StreamFsFetchNode {
11198                    node_inner: node_inner__,
11199                })
11200            }
11201        }
11202        deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
11203    }
11204}
11205impl serde::Serialize for StreamMessage {
11206    #[allow(deprecated)]
11207    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11208    where
11209        S: serde::Serializer,
11210    {
11211        use serde::ser::SerializeStruct;
11212        let mut len = 0;
11213        if self.stream_message.is_some() {
11214            len += 1;
11215        }
11216        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
11217        if let Some(v) = self.stream_message.as_ref() {
11218            match v {
11219                stream_message::StreamMessage::StreamChunk(v) => {
11220                    struct_ser.serialize_field("streamChunk", v)?;
11221                }
11222                stream_message::StreamMessage::Barrier(v) => {
11223                    struct_ser.serialize_field("barrier", v)?;
11224                }
11225                stream_message::StreamMessage::Watermark(v) => {
11226                    struct_ser.serialize_field("watermark", v)?;
11227                }
11228            }
11229        }
11230        struct_ser.end()
11231    }
11232}
11233impl<'de> serde::Deserialize<'de> for StreamMessage {
11234    #[allow(deprecated)]
11235    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11236    where
11237        D: serde::Deserializer<'de>,
11238    {
11239        const FIELDS: &[&str] = &[
11240            "stream_chunk",
11241            "streamChunk",
11242            "barrier",
11243            "watermark",
11244        ];
11245
11246        #[allow(clippy::enum_variant_names)]
11247        enum GeneratedField {
11248            StreamChunk,
11249            Barrier,
11250            Watermark,
11251        }
11252        impl<'de> serde::Deserialize<'de> for GeneratedField {
11253            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11254            where
11255                D: serde::Deserializer<'de>,
11256            {
11257                struct GeneratedVisitor;
11258
11259                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11260                    type Value = GeneratedField;
11261
11262                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11263                        write!(formatter, "expected one of: {:?}", &FIELDS)
11264                    }
11265
11266                    #[allow(unused_variables)]
11267                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11268                    where
11269                        E: serde::de::Error,
11270                    {
11271                        match value {
11272                            "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
11273                            "barrier" => Ok(GeneratedField::Barrier),
11274                            "watermark" => Ok(GeneratedField::Watermark),
11275                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11276                        }
11277                    }
11278                }
11279                deserializer.deserialize_identifier(GeneratedVisitor)
11280            }
11281        }
11282        struct GeneratedVisitor;
11283        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11284            type Value = StreamMessage;
11285
11286            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11287                formatter.write_str("struct stream_plan.StreamMessage")
11288            }
11289
11290            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
11291                where
11292                    V: serde::de::MapAccess<'de>,
11293            {
11294                let mut stream_message__ = None;
11295                while let Some(k) = map_.next_key()? {
11296                    match k {
11297                        GeneratedField::StreamChunk => {
11298                            if stream_message__.is_some() {
11299                                return Err(serde::de::Error::duplicate_field("streamChunk"));
11300                            }
11301                            stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
11302;
11303                        }
11304                        GeneratedField::Barrier => {
11305                            if stream_message__.is_some() {
11306                                return Err(serde::de::Error::duplicate_field("barrier"));
11307                            }
11308                            stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
11309;
11310                        }
11311                        GeneratedField::Watermark => {
11312                            if stream_message__.is_some() {
11313                                return Err(serde::de::Error::duplicate_field("watermark"));
11314                            }
11315                            stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
11316;
11317                        }
11318                    }
11319                }
11320                Ok(StreamMessage {
11321                    stream_message: stream_message__,
11322                })
11323            }
11324        }
11325        deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
11326    }
11327}
11328impl serde::Serialize for StreamMessageBatch {
11329    #[allow(deprecated)]
11330    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11331    where
11332        S: serde::Serializer,
11333    {
11334        use serde::ser::SerializeStruct;
11335        let mut len = 0;
11336        if self.stream_message_batch.is_some() {
11337            len += 1;
11338        }
11339        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
11340        if let Some(v) = self.stream_message_batch.as_ref() {
11341            match v {
11342                stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
11343                    struct_ser.serialize_field("streamChunk", v)?;
11344                }
11345                stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
11346                    struct_ser.serialize_field("barrierBatch", v)?;
11347                }
11348                stream_message_batch::StreamMessageBatch::Watermark(v) => {
11349                    struct_ser.serialize_field("watermark", v)?;
11350                }
11351            }
11352        }
11353        struct_ser.end()
11354    }
11355}
11356impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
11357    #[allow(deprecated)]
11358    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11359    where
11360        D: serde::Deserializer<'de>,
11361    {
11362        const FIELDS: &[&str] = &[
11363            "stream_chunk",
11364            "streamChunk",
11365            "barrier_batch",
11366            "barrierBatch",
11367            "watermark",
11368        ];
11369
11370        #[allow(clippy::enum_variant_names)]
11371        enum GeneratedField {
11372            StreamChunk,
11373            BarrierBatch,
11374            Watermark,
11375        }
11376        impl<'de> serde::Deserialize<'de> for GeneratedField {
11377            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11378            where
11379                D: serde::Deserializer<'de>,
11380            {
11381                struct GeneratedVisitor;
11382
11383                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11384                    type Value = GeneratedField;
11385
11386                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11387                        write!(formatter, "expected one of: {:?}", &FIELDS)
11388                    }
11389
11390                    #[allow(unused_variables)]
11391                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11392                    where
11393                        E: serde::de::Error,
11394                    {
11395                        match value {
11396                            "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
11397                            "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
11398                            "watermark" => Ok(GeneratedField::Watermark),
11399                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11400                        }
11401                    }
11402                }
11403                deserializer.deserialize_identifier(GeneratedVisitor)
11404            }
11405        }
11406        struct GeneratedVisitor;
11407        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11408            type Value = StreamMessageBatch;
11409
11410            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11411                formatter.write_str("struct stream_plan.StreamMessageBatch")
11412            }
11413
11414            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
11415                where
11416                    V: serde::de::MapAccess<'de>,
11417            {
11418                let mut stream_message_batch__ = None;
11419                while let Some(k) = map_.next_key()? {
11420                    match k {
11421                        GeneratedField::StreamChunk => {
11422                            if stream_message_batch__.is_some() {
11423                                return Err(serde::de::Error::duplicate_field("streamChunk"));
11424                            }
11425                            stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
11426;
11427                        }
11428                        GeneratedField::BarrierBatch => {
11429                            if stream_message_batch__.is_some() {
11430                                return Err(serde::de::Error::duplicate_field("barrierBatch"));
11431                            }
11432                            stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
11433;
11434                        }
11435                        GeneratedField::Watermark => {
11436                            if stream_message_batch__.is_some() {
11437                                return Err(serde::de::Error::duplicate_field("watermark"));
11438                            }
11439                            stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
11440;
11441                        }
11442                    }
11443                }
11444                Ok(StreamMessageBatch {
11445                    stream_message_batch: stream_message_batch__,
11446                })
11447            }
11448        }
11449        deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
11450    }
11451}
11452impl serde::Serialize for stream_message_batch::BarrierBatch {
11453    #[allow(deprecated)]
11454    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11455    where
11456        S: serde::Serializer,
11457    {
11458        use serde::ser::SerializeStruct;
11459        let mut len = 0;
11460        if !self.barriers.is_empty() {
11461            len += 1;
11462        }
11463        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
11464        if !self.barriers.is_empty() {
11465            struct_ser.serialize_field("barriers", &self.barriers)?;
11466        }
11467        struct_ser.end()
11468    }
11469}
11470impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
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            "barriers",
11478        ];
11479
11480        #[allow(clippy::enum_variant_names)]
11481        enum GeneratedField {
11482            Barriers,
11483        }
11484        impl<'de> serde::Deserialize<'de> for GeneratedField {
11485            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11486            where
11487                D: serde::Deserializer<'de>,
11488            {
11489                struct GeneratedVisitor;
11490
11491                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11492                    type Value = GeneratedField;
11493
11494                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11495                        write!(formatter, "expected one of: {:?}", &FIELDS)
11496                    }
11497
11498                    #[allow(unused_variables)]
11499                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11500                    where
11501                        E: serde::de::Error,
11502                    {
11503                        match value {
11504                            "barriers" => Ok(GeneratedField::Barriers),
11505                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11506                        }
11507                    }
11508                }
11509                deserializer.deserialize_identifier(GeneratedVisitor)
11510            }
11511        }
11512        struct GeneratedVisitor;
11513        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11514            type Value = stream_message_batch::BarrierBatch;
11515
11516            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11517                formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
11518            }
11519
11520            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
11521                where
11522                    V: serde::de::MapAccess<'de>,
11523            {
11524                let mut barriers__ = None;
11525                while let Some(k) = map_.next_key()? {
11526                    match k {
11527                        GeneratedField::Barriers => {
11528                            if barriers__.is_some() {
11529                                return Err(serde::de::Error::duplicate_field("barriers"));
11530                            }
11531                            barriers__ = Some(map_.next_value()?);
11532                        }
11533                    }
11534                }
11535                Ok(stream_message_batch::BarrierBatch {
11536                    barriers: barriers__.unwrap_or_default(),
11537                })
11538            }
11539        }
11540        deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
11541    }
11542}
11543impl serde::Serialize for StreamNode {
11544    #[allow(deprecated)]
11545    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11546    where
11547        S: serde::Serializer,
11548    {
11549        use serde::ser::SerializeStruct;
11550        let mut len = 0;
11551        if self.operator_id != 0 {
11552            len += 1;
11553        }
11554        if !self.input.is_empty() {
11555            len += 1;
11556        }
11557        if !self.stream_key.is_empty() {
11558            len += 1;
11559        }
11560        if self.append_only {
11561            len += 1;
11562        }
11563        if !self.identity.is_empty() {
11564            len += 1;
11565        }
11566        if !self.fields.is_empty() {
11567            len += 1;
11568        }
11569        if self.node_body.is_some() {
11570            len += 1;
11571        }
11572        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
11573        if self.operator_id != 0 {
11574            #[allow(clippy::needless_borrow)]
11575            #[allow(clippy::needless_borrows_for_generic_args)]
11576            struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
11577        }
11578        if !self.input.is_empty() {
11579            struct_ser.serialize_field("input", &self.input)?;
11580        }
11581        if !self.stream_key.is_empty() {
11582            struct_ser.serialize_field("streamKey", &self.stream_key)?;
11583        }
11584        if self.append_only {
11585            struct_ser.serialize_field("appendOnly", &self.append_only)?;
11586        }
11587        if !self.identity.is_empty() {
11588            struct_ser.serialize_field("identity", &self.identity)?;
11589        }
11590        if !self.fields.is_empty() {
11591            struct_ser.serialize_field("fields", &self.fields)?;
11592        }
11593        if let Some(v) = self.node_body.as_ref() {
11594            match v {
11595                stream_node::NodeBody::Source(v) => {
11596                    struct_ser.serialize_field("source", v)?;
11597                }
11598                stream_node::NodeBody::Project(v) => {
11599                    struct_ser.serialize_field("project", v)?;
11600                }
11601                stream_node::NodeBody::Filter(v) => {
11602                    struct_ser.serialize_field("filter", v)?;
11603                }
11604                stream_node::NodeBody::Materialize(v) => {
11605                    struct_ser.serialize_field("materialize", v)?;
11606                }
11607                stream_node::NodeBody::StatelessSimpleAgg(v) => {
11608                    struct_ser.serialize_field("statelessSimpleAgg", v)?;
11609                }
11610                stream_node::NodeBody::SimpleAgg(v) => {
11611                    struct_ser.serialize_field("simpleAgg", v)?;
11612                }
11613                stream_node::NodeBody::HashAgg(v) => {
11614                    struct_ser.serialize_field("hashAgg", v)?;
11615                }
11616                stream_node::NodeBody::AppendOnlyTopN(v) => {
11617                    struct_ser.serialize_field("appendOnlyTopN", v)?;
11618                }
11619                stream_node::NodeBody::HashJoin(v) => {
11620                    struct_ser.serialize_field("hashJoin", v)?;
11621                }
11622                stream_node::NodeBody::TopN(v) => {
11623                    struct_ser.serialize_field("topN", v)?;
11624                }
11625                stream_node::NodeBody::HopWindow(v) => {
11626                    struct_ser.serialize_field("hopWindow", v)?;
11627                }
11628                stream_node::NodeBody::Merge(v) => {
11629                    struct_ser.serialize_field("merge", v)?;
11630                }
11631                stream_node::NodeBody::Exchange(v) => {
11632                    struct_ser.serialize_field("exchange", v)?;
11633                }
11634                stream_node::NodeBody::StreamScan(v) => {
11635                    struct_ser.serialize_field("streamScan", v)?;
11636                }
11637                stream_node::NodeBody::BatchPlan(v) => {
11638                    struct_ser.serialize_field("batchPlan", v)?;
11639                }
11640                stream_node::NodeBody::Lookup(v) => {
11641                    struct_ser.serialize_field("lookup", v)?;
11642                }
11643                stream_node::NodeBody::Arrange(v) => {
11644                    struct_ser.serialize_field("arrange", v)?;
11645                }
11646                stream_node::NodeBody::LookupUnion(v) => {
11647                    struct_ser.serialize_field("lookupUnion", v)?;
11648                }
11649                stream_node::NodeBody::Union(v) => {
11650                    struct_ser.serialize_field("union", v)?;
11651                }
11652                stream_node::NodeBody::DeltaIndexJoin(v) => {
11653                    struct_ser.serialize_field("deltaIndexJoin", v)?;
11654                }
11655                stream_node::NodeBody::Sink(v) => {
11656                    struct_ser.serialize_field("sink", v)?;
11657                }
11658                stream_node::NodeBody::Expand(v) => {
11659                    struct_ser.serialize_field("expand", v)?;
11660                }
11661                stream_node::NodeBody::DynamicFilter(v) => {
11662                    struct_ser.serialize_field("dynamicFilter", v)?;
11663                }
11664                stream_node::NodeBody::ProjectSet(v) => {
11665                    struct_ser.serialize_field("projectSet", v)?;
11666                }
11667                stream_node::NodeBody::GroupTopN(v) => {
11668                    struct_ser.serialize_field("groupTopN", v)?;
11669                }
11670                stream_node::NodeBody::Sort(v) => {
11671                    struct_ser.serialize_field("sort", v)?;
11672                }
11673                stream_node::NodeBody::WatermarkFilter(v) => {
11674                    struct_ser.serialize_field("watermarkFilter", v)?;
11675                }
11676                stream_node::NodeBody::Dml(v) => {
11677                    struct_ser.serialize_field("dml", v)?;
11678                }
11679                stream_node::NodeBody::RowIdGen(v) => {
11680                    struct_ser.serialize_field("rowIdGen", v)?;
11681                }
11682                stream_node::NodeBody::Now(v) => {
11683                    struct_ser.serialize_field("now", v)?;
11684                }
11685                stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
11686                    struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
11687                }
11688                stream_node::NodeBody::TemporalJoin(v) => {
11689                    struct_ser.serialize_field("temporalJoin", v)?;
11690                }
11691                stream_node::NodeBody::BarrierRecv(v) => {
11692                    struct_ser.serialize_field("barrierRecv", v)?;
11693                }
11694                stream_node::NodeBody::Values(v) => {
11695                    struct_ser.serialize_field("values", v)?;
11696                }
11697                stream_node::NodeBody::AppendOnlyDedup(v) => {
11698                    struct_ser.serialize_field("appendOnlyDedup", v)?;
11699                }
11700                stream_node::NodeBody::NoOp(v) => {
11701                    struct_ser.serialize_field("noOp", v)?;
11702                }
11703                stream_node::NodeBody::EowcOverWindow(v) => {
11704                    struct_ser.serialize_field("eowcOverWindow", v)?;
11705                }
11706                stream_node::NodeBody::OverWindow(v) => {
11707                    struct_ser.serialize_field("overWindow", v)?;
11708                }
11709                stream_node::NodeBody::StreamFsFetch(v) => {
11710                    struct_ser.serialize_field("streamFsFetch", v)?;
11711                }
11712                stream_node::NodeBody::StreamCdcScan(v) => {
11713                    struct_ser.serialize_field("streamCdcScan", v)?;
11714                }
11715                stream_node::NodeBody::CdcFilter(v) => {
11716                    struct_ser.serialize_field("cdcFilter", v)?;
11717                }
11718                stream_node::NodeBody::SourceBackfill(v) => {
11719                    struct_ser.serialize_field("sourceBackfill", v)?;
11720                }
11721                stream_node::NodeBody::Changelog(v) => {
11722                    struct_ser.serialize_field("changelog", v)?;
11723                }
11724                stream_node::NodeBody::LocalApproxPercentile(v) => {
11725                    struct_ser.serialize_field("localApproxPercentile", v)?;
11726                }
11727                stream_node::NodeBody::GlobalApproxPercentile(v) => {
11728                    struct_ser.serialize_field("globalApproxPercentile", v)?;
11729                }
11730                stream_node::NodeBody::RowMerge(v) => {
11731                    struct_ser.serialize_field("rowMerge", v)?;
11732                }
11733                stream_node::NodeBody::AsOfJoin(v) => {
11734                    struct_ser.serialize_field("asOfJoin", v)?;
11735                }
11736                stream_node::NodeBody::SyncLogStore(v) => {
11737                    struct_ser.serialize_field("syncLogStore", v)?;
11738                }
11739                stream_node::NodeBody::MaterializedExprs(v) => {
11740                    struct_ser.serialize_field("materializedExprs", v)?;
11741                }
11742            }
11743        }
11744        struct_ser.end()
11745    }
11746}
11747impl<'de> serde::Deserialize<'de> for StreamNode {
11748    #[allow(deprecated)]
11749    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11750    where
11751        D: serde::Deserializer<'de>,
11752    {
11753        const FIELDS: &[&str] = &[
11754            "operator_id",
11755            "operatorId",
11756            "input",
11757            "stream_key",
11758            "streamKey",
11759            "append_only",
11760            "appendOnly",
11761            "identity",
11762            "fields",
11763            "source",
11764            "project",
11765            "filter",
11766            "materialize",
11767            "stateless_simple_agg",
11768            "statelessSimpleAgg",
11769            "simple_agg",
11770            "simpleAgg",
11771            "hash_agg",
11772            "hashAgg",
11773            "append_only_top_n",
11774            "appendOnlyTopN",
11775            "hash_join",
11776            "hashJoin",
11777            "top_n",
11778            "topN",
11779            "hop_window",
11780            "hopWindow",
11781            "merge",
11782            "exchange",
11783            "stream_scan",
11784            "streamScan",
11785            "batch_plan",
11786            "batchPlan",
11787            "lookup",
11788            "arrange",
11789            "lookup_union",
11790            "lookupUnion",
11791            "union",
11792            "delta_index_join",
11793            "deltaIndexJoin",
11794            "sink",
11795            "expand",
11796            "dynamic_filter",
11797            "dynamicFilter",
11798            "project_set",
11799            "projectSet",
11800            "group_top_n",
11801            "groupTopN",
11802            "sort",
11803            "watermark_filter",
11804            "watermarkFilter",
11805            "dml",
11806            "row_id_gen",
11807            "rowIdGen",
11808            "now",
11809            "append_only_group_top_n",
11810            "appendOnlyGroupTopN",
11811            "temporal_join",
11812            "temporalJoin",
11813            "barrier_recv",
11814            "barrierRecv",
11815            "values",
11816            "append_only_dedup",
11817            "appendOnlyDedup",
11818            "no_op",
11819            "noOp",
11820            "eowc_over_window",
11821            "eowcOverWindow",
11822            "over_window",
11823            "overWindow",
11824            "stream_fs_fetch",
11825            "streamFsFetch",
11826            "stream_cdc_scan",
11827            "streamCdcScan",
11828            "cdc_filter",
11829            "cdcFilter",
11830            "source_backfill",
11831            "sourceBackfill",
11832            "changelog",
11833            "local_approx_percentile",
11834            "localApproxPercentile",
11835            "global_approx_percentile",
11836            "globalApproxPercentile",
11837            "row_merge",
11838            "rowMerge",
11839            "as_of_join",
11840            "asOfJoin",
11841            "sync_log_store",
11842            "syncLogStore",
11843            "materialized_exprs",
11844            "materializedExprs",
11845        ];
11846
11847        #[allow(clippy::enum_variant_names)]
11848        enum GeneratedField {
11849            OperatorId,
11850            Input,
11851            StreamKey,
11852            AppendOnly,
11853            Identity,
11854            Fields,
11855            Source,
11856            Project,
11857            Filter,
11858            Materialize,
11859            StatelessSimpleAgg,
11860            SimpleAgg,
11861            HashAgg,
11862            AppendOnlyTopN,
11863            HashJoin,
11864            TopN,
11865            HopWindow,
11866            Merge,
11867            Exchange,
11868            StreamScan,
11869            BatchPlan,
11870            Lookup,
11871            Arrange,
11872            LookupUnion,
11873            Union,
11874            DeltaIndexJoin,
11875            Sink,
11876            Expand,
11877            DynamicFilter,
11878            ProjectSet,
11879            GroupTopN,
11880            Sort,
11881            WatermarkFilter,
11882            Dml,
11883            RowIdGen,
11884            Now,
11885            AppendOnlyGroupTopN,
11886            TemporalJoin,
11887            BarrierRecv,
11888            Values,
11889            AppendOnlyDedup,
11890            NoOp,
11891            EowcOverWindow,
11892            OverWindow,
11893            StreamFsFetch,
11894            StreamCdcScan,
11895            CdcFilter,
11896            SourceBackfill,
11897            Changelog,
11898            LocalApproxPercentile,
11899            GlobalApproxPercentile,
11900            RowMerge,
11901            AsOfJoin,
11902            SyncLogStore,
11903            MaterializedExprs,
11904        }
11905        impl<'de> serde::Deserialize<'de> for GeneratedField {
11906            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11907            where
11908                D: serde::Deserializer<'de>,
11909            {
11910                struct GeneratedVisitor;
11911
11912                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11913                    type Value = GeneratedField;
11914
11915                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11916                        write!(formatter, "expected one of: {:?}", &FIELDS)
11917                    }
11918
11919                    #[allow(unused_variables)]
11920                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11921                    where
11922                        E: serde::de::Error,
11923                    {
11924                        match value {
11925                            "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
11926                            "input" => Ok(GeneratedField::Input),
11927                            "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
11928                            "appendOnly" | "append_only" => Ok(GeneratedField::AppendOnly),
11929                            "identity" => Ok(GeneratedField::Identity),
11930                            "fields" => Ok(GeneratedField::Fields),
11931                            "source" => Ok(GeneratedField::Source),
11932                            "project" => Ok(GeneratedField::Project),
11933                            "filter" => Ok(GeneratedField::Filter),
11934                            "materialize" => Ok(GeneratedField::Materialize),
11935                            "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
11936                            "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
11937                            "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
11938                            "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
11939                            "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
11940                            "topN" | "top_n" => Ok(GeneratedField::TopN),
11941                            "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
11942                            "merge" => Ok(GeneratedField::Merge),
11943                            "exchange" => Ok(GeneratedField::Exchange),
11944                            "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
11945                            "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
11946                            "lookup" => Ok(GeneratedField::Lookup),
11947                            "arrange" => Ok(GeneratedField::Arrange),
11948                            "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
11949                            "union" => Ok(GeneratedField::Union),
11950                            "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
11951                            "sink" => Ok(GeneratedField::Sink),
11952                            "expand" => Ok(GeneratedField::Expand),
11953                            "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
11954                            "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
11955                            "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
11956                            "sort" => Ok(GeneratedField::Sort),
11957                            "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
11958                            "dml" => Ok(GeneratedField::Dml),
11959                            "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
11960                            "now" => Ok(GeneratedField::Now),
11961                            "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
11962                            "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
11963                            "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
11964                            "values" => Ok(GeneratedField::Values),
11965                            "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
11966                            "noOp" | "no_op" => Ok(GeneratedField::NoOp),
11967                            "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
11968                            "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
11969                            "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
11970                            "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
11971                            "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
11972                            "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
11973                            "changelog" => Ok(GeneratedField::Changelog),
11974                            "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
11975                            "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
11976                            "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
11977                            "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
11978                            "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
11979                            "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
11980                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11981                        }
11982                    }
11983                }
11984                deserializer.deserialize_identifier(GeneratedVisitor)
11985            }
11986        }
11987        struct GeneratedVisitor;
11988        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11989            type Value = StreamNode;
11990
11991            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11992                formatter.write_str("struct stream_plan.StreamNode")
11993            }
11994
11995            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
11996                where
11997                    V: serde::de::MapAccess<'de>,
11998            {
11999                let mut operator_id__ = None;
12000                let mut input__ = None;
12001                let mut stream_key__ = None;
12002                let mut append_only__ = None;
12003                let mut identity__ = None;
12004                let mut fields__ = None;
12005                let mut node_body__ = None;
12006                while let Some(k) = map_.next_key()? {
12007                    match k {
12008                        GeneratedField::OperatorId => {
12009                            if operator_id__.is_some() {
12010                                return Err(serde::de::Error::duplicate_field("operatorId"));
12011                            }
12012                            operator_id__ = 
12013                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12014                            ;
12015                        }
12016                        GeneratedField::Input => {
12017                            if input__.is_some() {
12018                                return Err(serde::de::Error::duplicate_field("input"));
12019                            }
12020                            input__ = Some(map_.next_value()?);
12021                        }
12022                        GeneratedField::StreamKey => {
12023                            if stream_key__.is_some() {
12024                                return Err(serde::de::Error::duplicate_field("streamKey"));
12025                            }
12026                            stream_key__ = 
12027                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12028                                    .into_iter().map(|x| x.0).collect())
12029                            ;
12030                        }
12031                        GeneratedField::AppendOnly => {
12032                            if append_only__.is_some() {
12033                                return Err(serde::de::Error::duplicate_field("appendOnly"));
12034                            }
12035                            append_only__ = Some(map_.next_value()?);
12036                        }
12037                        GeneratedField::Identity => {
12038                            if identity__.is_some() {
12039                                return Err(serde::de::Error::duplicate_field("identity"));
12040                            }
12041                            identity__ = Some(map_.next_value()?);
12042                        }
12043                        GeneratedField::Fields => {
12044                            if fields__.is_some() {
12045                                return Err(serde::de::Error::duplicate_field("fields"));
12046                            }
12047                            fields__ = Some(map_.next_value()?);
12048                        }
12049                        GeneratedField::Source => {
12050                            if node_body__.is_some() {
12051                                return Err(serde::de::Error::duplicate_field("source"));
12052                            }
12053                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
12054;
12055                        }
12056                        GeneratedField::Project => {
12057                            if node_body__.is_some() {
12058                                return Err(serde::de::Error::duplicate_field("project"));
12059                            }
12060                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
12061;
12062                        }
12063                        GeneratedField::Filter => {
12064                            if node_body__.is_some() {
12065                                return Err(serde::de::Error::duplicate_field("filter"));
12066                            }
12067                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
12068;
12069                        }
12070                        GeneratedField::Materialize => {
12071                            if node_body__.is_some() {
12072                                return Err(serde::de::Error::duplicate_field("materialize"));
12073                            }
12074                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
12075;
12076                        }
12077                        GeneratedField::StatelessSimpleAgg => {
12078                            if node_body__.is_some() {
12079                                return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
12080                            }
12081                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
12082;
12083                        }
12084                        GeneratedField::SimpleAgg => {
12085                            if node_body__.is_some() {
12086                                return Err(serde::de::Error::duplicate_field("simpleAgg"));
12087                            }
12088                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
12089;
12090                        }
12091                        GeneratedField::HashAgg => {
12092                            if node_body__.is_some() {
12093                                return Err(serde::de::Error::duplicate_field("hashAgg"));
12094                            }
12095                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
12096;
12097                        }
12098                        GeneratedField::AppendOnlyTopN => {
12099                            if node_body__.is_some() {
12100                                return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
12101                            }
12102                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
12103;
12104                        }
12105                        GeneratedField::HashJoin => {
12106                            if node_body__.is_some() {
12107                                return Err(serde::de::Error::duplicate_field("hashJoin"));
12108                            }
12109                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
12110;
12111                        }
12112                        GeneratedField::TopN => {
12113                            if node_body__.is_some() {
12114                                return Err(serde::de::Error::duplicate_field("topN"));
12115                            }
12116                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
12117;
12118                        }
12119                        GeneratedField::HopWindow => {
12120                            if node_body__.is_some() {
12121                                return Err(serde::de::Error::duplicate_field("hopWindow"));
12122                            }
12123                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
12124;
12125                        }
12126                        GeneratedField::Merge => {
12127                            if node_body__.is_some() {
12128                                return Err(serde::de::Error::duplicate_field("merge"));
12129                            }
12130                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
12131;
12132                        }
12133                        GeneratedField::Exchange => {
12134                            if node_body__.is_some() {
12135                                return Err(serde::de::Error::duplicate_field("exchange"));
12136                            }
12137                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
12138;
12139                        }
12140                        GeneratedField::StreamScan => {
12141                            if node_body__.is_some() {
12142                                return Err(serde::de::Error::duplicate_field("streamScan"));
12143                            }
12144                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
12145;
12146                        }
12147                        GeneratedField::BatchPlan => {
12148                            if node_body__.is_some() {
12149                                return Err(serde::de::Error::duplicate_field("batchPlan"));
12150                            }
12151                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
12152;
12153                        }
12154                        GeneratedField::Lookup => {
12155                            if node_body__.is_some() {
12156                                return Err(serde::de::Error::duplicate_field("lookup"));
12157                            }
12158                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
12159;
12160                        }
12161                        GeneratedField::Arrange => {
12162                            if node_body__.is_some() {
12163                                return Err(serde::de::Error::duplicate_field("arrange"));
12164                            }
12165                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
12166;
12167                        }
12168                        GeneratedField::LookupUnion => {
12169                            if node_body__.is_some() {
12170                                return Err(serde::de::Error::duplicate_field("lookupUnion"));
12171                            }
12172                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
12173;
12174                        }
12175                        GeneratedField::Union => {
12176                            if node_body__.is_some() {
12177                                return Err(serde::de::Error::duplicate_field("union"));
12178                            }
12179                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
12180;
12181                        }
12182                        GeneratedField::DeltaIndexJoin => {
12183                            if node_body__.is_some() {
12184                                return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
12185                            }
12186                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
12187;
12188                        }
12189                        GeneratedField::Sink => {
12190                            if node_body__.is_some() {
12191                                return Err(serde::de::Error::duplicate_field("sink"));
12192                            }
12193                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
12194;
12195                        }
12196                        GeneratedField::Expand => {
12197                            if node_body__.is_some() {
12198                                return Err(serde::de::Error::duplicate_field("expand"));
12199                            }
12200                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
12201;
12202                        }
12203                        GeneratedField::DynamicFilter => {
12204                            if node_body__.is_some() {
12205                                return Err(serde::de::Error::duplicate_field("dynamicFilter"));
12206                            }
12207                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
12208;
12209                        }
12210                        GeneratedField::ProjectSet => {
12211                            if node_body__.is_some() {
12212                                return Err(serde::de::Error::duplicate_field("projectSet"));
12213                            }
12214                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
12215;
12216                        }
12217                        GeneratedField::GroupTopN => {
12218                            if node_body__.is_some() {
12219                                return Err(serde::de::Error::duplicate_field("groupTopN"));
12220                            }
12221                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
12222;
12223                        }
12224                        GeneratedField::Sort => {
12225                            if node_body__.is_some() {
12226                                return Err(serde::de::Error::duplicate_field("sort"));
12227                            }
12228                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
12229;
12230                        }
12231                        GeneratedField::WatermarkFilter => {
12232                            if node_body__.is_some() {
12233                                return Err(serde::de::Error::duplicate_field("watermarkFilter"));
12234                            }
12235                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
12236;
12237                        }
12238                        GeneratedField::Dml => {
12239                            if node_body__.is_some() {
12240                                return Err(serde::de::Error::duplicate_field("dml"));
12241                            }
12242                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
12243;
12244                        }
12245                        GeneratedField::RowIdGen => {
12246                            if node_body__.is_some() {
12247                                return Err(serde::de::Error::duplicate_field("rowIdGen"));
12248                            }
12249                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
12250;
12251                        }
12252                        GeneratedField::Now => {
12253                            if node_body__.is_some() {
12254                                return Err(serde::de::Error::duplicate_field("now"));
12255                            }
12256                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
12257;
12258                        }
12259                        GeneratedField::AppendOnlyGroupTopN => {
12260                            if node_body__.is_some() {
12261                                return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
12262                            }
12263                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
12264;
12265                        }
12266                        GeneratedField::TemporalJoin => {
12267                            if node_body__.is_some() {
12268                                return Err(serde::de::Error::duplicate_field("temporalJoin"));
12269                            }
12270                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
12271;
12272                        }
12273                        GeneratedField::BarrierRecv => {
12274                            if node_body__.is_some() {
12275                                return Err(serde::de::Error::duplicate_field("barrierRecv"));
12276                            }
12277                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
12278;
12279                        }
12280                        GeneratedField::Values => {
12281                            if node_body__.is_some() {
12282                                return Err(serde::de::Error::duplicate_field("values"));
12283                            }
12284                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
12285;
12286                        }
12287                        GeneratedField::AppendOnlyDedup => {
12288                            if node_body__.is_some() {
12289                                return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
12290                            }
12291                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
12292;
12293                        }
12294                        GeneratedField::NoOp => {
12295                            if node_body__.is_some() {
12296                                return Err(serde::de::Error::duplicate_field("noOp"));
12297                            }
12298                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
12299;
12300                        }
12301                        GeneratedField::EowcOverWindow => {
12302                            if node_body__.is_some() {
12303                                return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
12304                            }
12305                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
12306;
12307                        }
12308                        GeneratedField::OverWindow => {
12309                            if node_body__.is_some() {
12310                                return Err(serde::de::Error::duplicate_field("overWindow"));
12311                            }
12312                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
12313;
12314                        }
12315                        GeneratedField::StreamFsFetch => {
12316                            if node_body__.is_some() {
12317                                return Err(serde::de::Error::duplicate_field("streamFsFetch"));
12318                            }
12319                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
12320;
12321                        }
12322                        GeneratedField::StreamCdcScan => {
12323                            if node_body__.is_some() {
12324                                return Err(serde::de::Error::duplicate_field("streamCdcScan"));
12325                            }
12326                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
12327;
12328                        }
12329                        GeneratedField::CdcFilter => {
12330                            if node_body__.is_some() {
12331                                return Err(serde::de::Error::duplicate_field("cdcFilter"));
12332                            }
12333                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
12334;
12335                        }
12336                        GeneratedField::SourceBackfill => {
12337                            if node_body__.is_some() {
12338                                return Err(serde::de::Error::duplicate_field("sourceBackfill"));
12339                            }
12340                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
12341;
12342                        }
12343                        GeneratedField::Changelog => {
12344                            if node_body__.is_some() {
12345                                return Err(serde::de::Error::duplicate_field("changelog"));
12346                            }
12347                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
12348;
12349                        }
12350                        GeneratedField::LocalApproxPercentile => {
12351                            if node_body__.is_some() {
12352                                return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
12353                            }
12354                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
12355;
12356                        }
12357                        GeneratedField::GlobalApproxPercentile => {
12358                            if node_body__.is_some() {
12359                                return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
12360                            }
12361                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
12362;
12363                        }
12364                        GeneratedField::RowMerge => {
12365                            if node_body__.is_some() {
12366                                return Err(serde::de::Error::duplicate_field("rowMerge"));
12367                            }
12368                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
12369;
12370                        }
12371                        GeneratedField::AsOfJoin => {
12372                            if node_body__.is_some() {
12373                                return Err(serde::de::Error::duplicate_field("asOfJoin"));
12374                            }
12375                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
12376;
12377                        }
12378                        GeneratedField::SyncLogStore => {
12379                            if node_body__.is_some() {
12380                                return Err(serde::de::Error::duplicate_field("syncLogStore"));
12381                            }
12382                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
12383;
12384                        }
12385                        GeneratedField::MaterializedExprs => {
12386                            if node_body__.is_some() {
12387                                return Err(serde::de::Error::duplicate_field("materializedExprs"));
12388                            }
12389                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
12390;
12391                        }
12392                    }
12393                }
12394                Ok(StreamNode {
12395                    operator_id: operator_id__.unwrap_or_default(),
12396                    input: input__.unwrap_or_default(),
12397                    stream_key: stream_key__.unwrap_or_default(),
12398                    append_only: append_only__.unwrap_or_default(),
12399                    identity: identity__.unwrap_or_default(),
12400                    fields: fields__.unwrap_or_default(),
12401                    node_body: node_body__,
12402                })
12403            }
12404        }
12405        deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
12406    }
12407}
12408impl serde::Serialize for StreamScanNode {
12409    #[allow(deprecated)]
12410    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12411    where
12412        S: serde::Serializer,
12413    {
12414        use serde::ser::SerializeStruct;
12415        let mut len = 0;
12416        if self.table_id != 0 {
12417            len += 1;
12418        }
12419        if !self.upstream_column_ids.is_empty() {
12420            len += 1;
12421        }
12422        if !self.output_indices.is_empty() {
12423            len += 1;
12424        }
12425        if self.stream_scan_type != 0 {
12426            len += 1;
12427        }
12428        if self.state_table.is_some() {
12429            len += 1;
12430        }
12431        if self.table_desc.is_some() {
12432            len += 1;
12433        }
12434        if self.rate_limit.is_some() {
12435            len += 1;
12436        }
12437        if self.snapshot_read_barrier_interval != 0 {
12438            len += 1;
12439        }
12440        if self.arrangement_table.is_some() {
12441            len += 1;
12442        }
12443        if self.snapshot_backfill_epoch.is_some() {
12444            len += 1;
12445        }
12446        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
12447        if self.table_id != 0 {
12448            struct_ser.serialize_field("tableId", &self.table_id)?;
12449        }
12450        if !self.upstream_column_ids.is_empty() {
12451            struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
12452        }
12453        if !self.output_indices.is_empty() {
12454            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
12455        }
12456        if self.stream_scan_type != 0 {
12457            let v = StreamScanType::try_from(self.stream_scan_type)
12458                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
12459            struct_ser.serialize_field("streamScanType", &v)?;
12460        }
12461        if let Some(v) = self.state_table.as_ref() {
12462            struct_ser.serialize_field("stateTable", v)?;
12463        }
12464        if let Some(v) = self.table_desc.as_ref() {
12465            struct_ser.serialize_field("tableDesc", v)?;
12466        }
12467        if let Some(v) = self.rate_limit.as_ref() {
12468            struct_ser.serialize_field("rateLimit", v)?;
12469        }
12470        if self.snapshot_read_barrier_interval != 0 {
12471            struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
12472        }
12473        if let Some(v) = self.arrangement_table.as_ref() {
12474            struct_ser.serialize_field("arrangementTable", v)?;
12475        }
12476        if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
12477            #[allow(clippy::needless_borrow)]
12478            #[allow(clippy::needless_borrows_for_generic_args)]
12479            struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
12480        }
12481        struct_ser.end()
12482    }
12483}
12484impl<'de> serde::Deserialize<'de> for StreamScanNode {
12485    #[allow(deprecated)]
12486    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12487    where
12488        D: serde::Deserializer<'de>,
12489    {
12490        const FIELDS: &[&str] = &[
12491            "table_id",
12492            "tableId",
12493            "upstream_column_ids",
12494            "upstreamColumnIds",
12495            "output_indices",
12496            "outputIndices",
12497            "stream_scan_type",
12498            "streamScanType",
12499            "state_table",
12500            "stateTable",
12501            "table_desc",
12502            "tableDesc",
12503            "rate_limit",
12504            "rateLimit",
12505            "snapshot_read_barrier_interval",
12506            "snapshotReadBarrierInterval",
12507            "arrangement_table",
12508            "arrangementTable",
12509            "snapshot_backfill_epoch",
12510            "snapshotBackfillEpoch",
12511        ];
12512
12513        #[allow(clippy::enum_variant_names)]
12514        enum GeneratedField {
12515            TableId,
12516            UpstreamColumnIds,
12517            OutputIndices,
12518            StreamScanType,
12519            StateTable,
12520            TableDesc,
12521            RateLimit,
12522            SnapshotReadBarrierInterval,
12523            ArrangementTable,
12524            SnapshotBackfillEpoch,
12525        }
12526        impl<'de> serde::Deserialize<'de> for GeneratedField {
12527            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12528            where
12529                D: serde::Deserializer<'de>,
12530            {
12531                struct GeneratedVisitor;
12532
12533                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12534                    type Value = GeneratedField;
12535
12536                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12537                        write!(formatter, "expected one of: {:?}", &FIELDS)
12538                    }
12539
12540                    #[allow(unused_variables)]
12541                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12542                    where
12543                        E: serde::de::Error,
12544                    {
12545                        match value {
12546                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
12547                            "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
12548                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
12549                            "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
12550                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12551                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
12552                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12553                            "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
12554                            "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
12555                            "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
12556                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12557                        }
12558                    }
12559                }
12560                deserializer.deserialize_identifier(GeneratedVisitor)
12561            }
12562        }
12563        struct GeneratedVisitor;
12564        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12565            type Value = StreamScanNode;
12566
12567            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12568                formatter.write_str("struct stream_plan.StreamScanNode")
12569            }
12570
12571            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
12572                where
12573                    V: serde::de::MapAccess<'de>,
12574            {
12575                let mut table_id__ = None;
12576                let mut upstream_column_ids__ = None;
12577                let mut output_indices__ = None;
12578                let mut stream_scan_type__ = None;
12579                let mut state_table__ = None;
12580                let mut table_desc__ = None;
12581                let mut rate_limit__ = None;
12582                let mut snapshot_read_barrier_interval__ = None;
12583                let mut arrangement_table__ = None;
12584                let mut snapshot_backfill_epoch__ = None;
12585                while let Some(k) = map_.next_key()? {
12586                    match k {
12587                        GeneratedField::TableId => {
12588                            if table_id__.is_some() {
12589                                return Err(serde::de::Error::duplicate_field("tableId"));
12590                            }
12591                            table_id__ = 
12592                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12593                            ;
12594                        }
12595                        GeneratedField::UpstreamColumnIds => {
12596                            if upstream_column_ids__.is_some() {
12597                                return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
12598                            }
12599                            upstream_column_ids__ = 
12600                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12601                                    .into_iter().map(|x| x.0).collect())
12602                            ;
12603                        }
12604                        GeneratedField::OutputIndices => {
12605                            if output_indices__.is_some() {
12606                                return Err(serde::de::Error::duplicate_field("outputIndices"));
12607                            }
12608                            output_indices__ = 
12609                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12610                                    .into_iter().map(|x| x.0).collect())
12611                            ;
12612                        }
12613                        GeneratedField::StreamScanType => {
12614                            if stream_scan_type__.is_some() {
12615                                return Err(serde::de::Error::duplicate_field("streamScanType"));
12616                            }
12617                            stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
12618                        }
12619                        GeneratedField::StateTable => {
12620                            if state_table__.is_some() {
12621                                return Err(serde::de::Error::duplicate_field("stateTable"));
12622                            }
12623                            state_table__ = map_.next_value()?;
12624                        }
12625                        GeneratedField::TableDesc => {
12626                            if table_desc__.is_some() {
12627                                return Err(serde::de::Error::duplicate_field("tableDesc"));
12628                            }
12629                            table_desc__ = map_.next_value()?;
12630                        }
12631                        GeneratedField::RateLimit => {
12632                            if rate_limit__.is_some() {
12633                                return Err(serde::de::Error::duplicate_field("rateLimit"));
12634                            }
12635                            rate_limit__ = 
12636                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12637                            ;
12638                        }
12639                        GeneratedField::SnapshotReadBarrierInterval => {
12640                            if snapshot_read_barrier_interval__.is_some() {
12641                                return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
12642                            }
12643                            snapshot_read_barrier_interval__ = 
12644                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12645                            ;
12646                        }
12647                        GeneratedField::ArrangementTable => {
12648                            if arrangement_table__.is_some() {
12649                                return Err(serde::de::Error::duplicate_field("arrangementTable"));
12650                            }
12651                            arrangement_table__ = map_.next_value()?;
12652                        }
12653                        GeneratedField::SnapshotBackfillEpoch => {
12654                            if snapshot_backfill_epoch__.is_some() {
12655                                return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
12656                            }
12657                            snapshot_backfill_epoch__ = 
12658                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12659                            ;
12660                        }
12661                    }
12662                }
12663                Ok(StreamScanNode {
12664                    table_id: table_id__.unwrap_or_default(),
12665                    upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
12666                    output_indices: output_indices__.unwrap_or_default(),
12667                    stream_scan_type: stream_scan_type__.unwrap_or_default(),
12668                    state_table: state_table__,
12669                    table_desc: table_desc__,
12670                    rate_limit: rate_limit__,
12671                    snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
12672                    arrangement_table: arrangement_table__,
12673                    snapshot_backfill_epoch: snapshot_backfill_epoch__,
12674                })
12675            }
12676        }
12677        deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
12678    }
12679}
12680impl serde::Serialize for StreamScanType {
12681    #[allow(deprecated)]
12682    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12683    where
12684        S: serde::Serializer,
12685    {
12686        let variant = match self {
12687            Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
12688            Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
12689            Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
12690            Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
12691            Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
12692            Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
12693            Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
12694            Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
12695        };
12696        serializer.serialize_str(variant)
12697    }
12698}
12699impl<'de> serde::Deserialize<'de> for StreamScanType {
12700    #[allow(deprecated)]
12701    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12702    where
12703        D: serde::Deserializer<'de>,
12704    {
12705        const FIELDS: &[&str] = &[
12706            "STREAM_SCAN_TYPE_UNSPECIFIED",
12707            "STREAM_SCAN_TYPE_CHAIN",
12708            "STREAM_SCAN_TYPE_REARRANGE",
12709            "STREAM_SCAN_TYPE_BACKFILL",
12710            "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
12711            "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
12712            "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
12713            "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
12714        ];
12715
12716        struct GeneratedVisitor;
12717
12718        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12719            type Value = StreamScanType;
12720
12721            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12722                write!(formatter, "expected one of: {:?}", &FIELDS)
12723            }
12724
12725            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
12726            where
12727                E: serde::de::Error,
12728            {
12729                i32::try_from(v)
12730                    .ok()
12731                    .and_then(|x| x.try_into().ok())
12732                    .ok_or_else(|| {
12733                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
12734                    })
12735            }
12736
12737            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
12738            where
12739                E: serde::de::Error,
12740            {
12741                i32::try_from(v)
12742                    .ok()
12743                    .and_then(|x| x.try_into().ok())
12744                    .ok_or_else(|| {
12745                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
12746                    })
12747            }
12748
12749            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
12750            where
12751                E: serde::de::Error,
12752            {
12753                match value {
12754                    "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
12755                    "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
12756                    "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
12757                    "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
12758                    "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
12759                    "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
12760                    "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
12761                    "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
12762                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
12763                }
12764            }
12765        }
12766        deserializer.deserialize_any(GeneratedVisitor)
12767    }
12768}
12769impl serde::Serialize for StreamSource {
12770    #[allow(deprecated)]
12771    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12772    where
12773        S: serde::Serializer,
12774    {
12775        use serde::ser::SerializeStruct;
12776        let mut len = 0;
12777        if self.source_id != 0 {
12778            len += 1;
12779        }
12780        if self.state_table.is_some() {
12781            len += 1;
12782        }
12783        if self.row_id_index.is_some() {
12784            len += 1;
12785        }
12786        if !self.columns.is_empty() {
12787            len += 1;
12788        }
12789        if !self.with_properties.is_empty() {
12790            len += 1;
12791        }
12792        if self.info.is_some() {
12793            len += 1;
12794        }
12795        if !self.source_name.is_empty() {
12796            len += 1;
12797        }
12798        if self.rate_limit.is_some() {
12799            len += 1;
12800        }
12801        if !self.secret_refs.is_empty() {
12802            len += 1;
12803        }
12804        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
12805        if self.source_id != 0 {
12806            struct_ser.serialize_field("sourceId", &self.source_id)?;
12807        }
12808        if let Some(v) = self.state_table.as_ref() {
12809            struct_ser.serialize_field("stateTable", v)?;
12810        }
12811        if let Some(v) = self.row_id_index.as_ref() {
12812            struct_ser.serialize_field("rowIdIndex", v)?;
12813        }
12814        if !self.columns.is_empty() {
12815            struct_ser.serialize_field("columns", &self.columns)?;
12816        }
12817        if !self.with_properties.is_empty() {
12818            struct_ser.serialize_field("withProperties", &self.with_properties)?;
12819        }
12820        if let Some(v) = self.info.as_ref() {
12821            struct_ser.serialize_field("info", v)?;
12822        }
12823        if !self.source_name.is_empty() {
12824            struct_ser.serialize_field("sourceName", &self.source_name)?;
12825        }
12826        if let Some(v) = self.rate_limit.as_ref() {
12827            struct_ser.serialize_field("rateLimit", v)?;
12828        }
12829        if !self.secret_refs.is_empty() {
12830            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
12831        }
12832        struct_ser.end()
12833    }
12834}
12835impl<'de> serde::Deserialize<'de> for StreamSource {
12836    #[allow(deprecated)]
12837    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12838    where
12839        D: serde::Deserializer<'de>,
12840    {
12841        const FIELDS: &[&str] = &[
12842            "source_id",
12843            "sourceId",
12844            "state_table",
12845            "stateTable",
12846            "row_id_index",
12847            "rowIdIndex",
12848            "columns",
12849            "with_properties",
12850            "withProperties",
12851            "info",
12852            "source_name",
12853            "sourceName",
12854            "rate_limit",
12855            "rateLimit",
12856            "secret_refs",
12857            "secretRefs",
12858        ];
12859
12860        #[allow(clippy::enum_variant_names)]
12861        enum GeneratedField {
12862            SourceId,
12863            StateTable,
12864            RowIdIndex,
12865            Columns,
12866            WithProperties,
12867            Info,
12868            SourceName,
12869            RateLimit,
12870            SecretRefs,
12871        }
12872        impl<'de> serde::Deserialize<'de> for GeneratedField {
12873            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12874            where
12875                D: serde::Deserializer<'de>,
12876            {
12877                struct GeneratedVisitor;
12878
12879                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12880                    type Value = GeneratedField;
12881
12882                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12883                        write!(formatter, "expected one of: {:?}", &FIELDS)
12884                    }
12885
12886                    #[allow(unused_variables)]
12887                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12888                    where
12889                        E: serde::de::Error,
12890                    {
12891                        match value {
12892                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
12893                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
12894                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
12895                            "columns" => Ok(GeneratedField::Columns),
12896                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
12897                            "info" => Ok(GeneratedField::Info),
12898                            "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
12899                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
12900                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
12901                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12902                        }
12903                    }
12904                }
12905                deserializer.deserialize_identifier(GeneratedVisitor)
12906            }
12907        }
12908        struct GeneratedVisitor;
12909        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12910            type Value = StreamSource;
12911
12912            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12913                formatter.write_str("struct stream_plan.StreamSource")
12914            }
12915
12916            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
12917                where
12918                    V: serde::de::MapAccess<'de>,
12919            {
12920                let mut source_id__ = None;
12921                let mut state_table__ = None;
12922                let mut row_id_index__ = None;
12923                let mut columns__ = None;
12924                let mut with_properties__ = None;
12925                let mut info__ = None;
12926                let mut source_name__ = None;
12927                let mut rate_limit__ = None;
12928                let mut secret_refs__ = None;
12929                while let Some(k) = map_.next_key()? {
12930                    match k {
12931                        GeneratedField::SourceId => {
12932                            if source_id__.is_some() {
12933                                return Err(serde::de::Error::duplicate_field("sourceId"));
12934                            }
12935                            source_id__ = 
12936                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12937                            ;
12938                        }
12939                        GeneratedField::StateTable => {
12940                            if state_table__.is_some() {
12941                                return Err(serde::de::Error::duplicate_field("stateTable"));
12942                            }
12943                            state_table__ = map_.next_value()?;
12944                        }
12945                        GeneratedField::RowIdIndex => {
12946                            if row_id_index__.is_some() {
12947                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
12948                            }
12949                            row_id_index__ = 
12950                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12951                            ;
12952                        }
12953                        GeneratedField::Columns => {
12954                            if columns__.is_some() {
12955                                return Err(serde::de::Error::duplicate_field("columns"));
12956                            }
12957                            columns__ = Some(map_.next_value()?);
12958                        }
12959                        GeneratedField::WithProperties => {
12960                            if with_properties__.is_some() {
12961                                return Err(serde::de::Error::duplicate_field("withProperties"));
12962                            }
12963                            with_properties__ = Some(
12964                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
12965                            );
12966                        }
12967                        GeneratedField::Info => {
12968                            if info__.is_some() {
12969                                return Err(serde::de::Error::duplicate_field("info"));
12970                            }
12971                            info__ = map_.next_value()?;
12972                        }
12973                        GeneratedField::SourceName => {
12974                            if source_name__.is_some() {
12975                                return Err(serde::de::Error::duplicate_field("sourceName"));
12976                            }
12977                            source_name__ = Some(map_.next_value()?);
12978                        }
12979                        GeneratedField::RateLimit => {
12980                            if rate_limit__.is_some() {
12981                                return Err(serde::de::Error::duplicate_field("rateLimit"));
12982                            }
12983                            rate_limit__ = 
12984                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
12985                            ;
12986                        }
12987                        GeneratedField::SecretRefs => {
12988                            if secret_refs__.is_some() {
12989                                return Err(serde::de::Error::duplicate_field("secretRefs"));
12990                            }
12991                            secret_refs__ = Some(
12992                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
12993                            );
12994                        }
12995                    }
12996                }
12997                Ok(StreamSource {
12998                    source_id: source_id__.unwrap_or_default(),
12999                    state_table: state_table__,
13000                    row_id_index: row_id_index__,
13001                    columns: columns__.unwrap_or_default(),
13002                    with_properties: with_properties__.unwrap_or_default(),
13003                    info: info__,
13004                    source_name: source_name__.unwrap_or_default(),
13005                    rate_limit: rate_limit__,
13006                    secret_refs: secret_refs__.unwrap_or_default(),
13007                })
13008            }
13009        }
13010        deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
13011    }
13012}
13013impl serde::Serialize for SubscriptionUpstreamInfo {
13014    #[allow(deprecated)]
13015    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13016    where
13017        S: serde::Serializer,
13018    {
13019        use serde::ser::SerializeStruct;
13020        let mut len = 0;
13021        if self.subscriber_id != 0 {
13022            len += 1;
13023        }
13024        if self.upstream_mv_table_id != 0 {
13025            len += 1;
13026        }
13027        let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
13028        if self.subscriber_id != 0 {
13029            struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
13030        }
13031        if self.upstream_mv_table_id != 0 {
13032            struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
13033        }
13034        struct_ser.end()
13035    }
13036}
13037impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
13038    #[allow(deprecated)]
13039    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13040    where
13041        D: serde::Deserializer<'de>,
13042    {
13043        const FIELDS: &[&str] = &[
13044            "subscriber_id",
13045            "subscriberId",
13046            "upstream_mv_table_id",
13047            "upstreamMvTableId",
13048        ];
13049
13050        #[allow(clippy::enum_variant_names)]
13051        enum GeneratedField {
13052            SubscriberId,
13053            UpstreamMvTableId,
13054        }
13055        impl<'de> serde::Deserialize<'de> for GeneratedField {
13056            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13057            where
13058                D: serde::Deserializer<'de>,
13059            {
13060                struct GeneratedVisitor;
13061
13062                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13063                    type Value = GeneratedField;
13064
13065                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13066                        write!(formatter, "expected one of: {:?}", &FIELDS)
13067                    }
13068
13069                    #[allow(unused_variables)]
13070                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13071                    where
13072                        E: serde::de::Error,
13073                    {
13074                        match value {
13075                            "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
13076                            "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
13077                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13078                        }
13079                    }
13080                }
13081                deserializer.deserialize_identifier(GeneratedVisitor)
13082            }
13083        }
13084        struct GeneratedVisitor;
13085        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13086            type Value = SubscriptionUpstreamInfo;
13087
13088            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13089                formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
13090            }
13091
13092            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
13093                where
13094                    V: serde::de::MapAccess<'de>,
13095            {
13096                let mut subscriber_id__ = None;
13097                let mut upstream_mv_table_id__ = None;
13098                while let Some(k) = map_.next_key()? {
13099                    match k {
13100                        GeneratedField::SubscriberId => {
13101                            if subscriber_id__.is_some() {
13102                                return Err(serde::de::Error::duplicate_field("subscriberId"));
13103                            }
13104                            subscriber_id__ = 
13105                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13106                            ;
13107                        }
13108                        GeneratedField::UpstreamMvTableId => {
13109                            if upstream_mv_table_id__.is_some() {
13110                                return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
13111                            }
13112                            upstream_mv_table_id__ = 
13113                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13114                            ;
13115                        }
13116                    }
13117                }
13118                Ok(SubscriptionUpstreamInfo {
13119                    subscriber_id: subscriber_id__.unwrap_or_default(),
13120                    upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
13121                })
13122            }
13123        }
13124        deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
13125    }
13126}
13127impl serde::Serialize for SyncLogStoreNode {
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.log_store_table.is_some() {
13136            len += 1;
13137        }
13138        if self.pause_duration_ms != 0 {
13139            len += 1;
13140        }
13141        if self.buffer_size != 0 {
13142            len += 1;
13143        }
13144        if self.aligned {
13145            len += 1;
13146        }
13147        let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
13148        if let Some(v) = self.log_store_table.as_ref() {
13149            struct_ser.serialize_field("logStoreTable", v)?;
13150        }
13151        if self.pause_duration_ms != 0 {
13152            struct_ser.serialize_field("pauseDurationMs", &self.pause_duration_ms)?;
13153        }
13154        if self.buffer_size != 0 {
13155            struct_ser.serialize_field("bufferSize", &self.buffer_size)?;
13156        }
13157        if self.aligned {
13158            struct_ser.serialize_field("aligned", &self.aligned)?;
13159        }
13160        struct_ser.end()
13161    }
13162}
13163impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
13164    #[allow(deprecated)]
13165    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13166    where
13167        D: serde::Deserializer<'de>,
13168    {
13169        const FIELDS: &[&str] = &[
13170            "log_store_table",
13171            "logStoreTable",
13172            "pause_duration_ms",
13173            "pauseDurationMs",
13174            "buffer_size",
13175            "bufferSize",
13176            "aligned",
13177        ];
13178
13179        #[allow(clippy::enum_variant_names)]
13180        enum GeneratedField {
13181            LogStoreTable,
13182            PauseDurationMs,
13183            BufferSize,
13184            Aligned,
13185        }
13186        impl<'de> serde::Deserialize<'de> for GeneratedField {
13187            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13188            where
13189                D: serde::Deserializer<'de>,
13190            {
13191                struct GeneratedVisitor;
13192
13193                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13194                    type Value = GeneratedField;
13195
13196                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13197                        write!(formatter, "expected one of: {:?}", &FIELDS)
13198                    }
13199
13200                    #[allow(unused_variables)]
13201                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13202                    where
13203                        E: serde::de::Error,
13204                    {
13205                        match value {
13206                            "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
13207                            "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
13208                            "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
13209                            "aligned" => Ok(GeneratedField::Aligned),
13210                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13211                        }
13212                    }
13213                }
13214                deserializer.deserialize_identifier(GeneratedVisitor)
13215            }
13216        }
13217        struct GeneratedVisitor;
13218        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13219            type Value = SyncLogStoreNode;
13220
13221            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13222                formatter.write_str("struct stream_plan.SyncLogStoreNode")
13223            }
13224
13225            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
13226                where
13227                    V: serde::de::MapAccess<'de>,
13228            {
13229                let mut log_store_table__ = None;
13230                let mut pause_duration_ms__ = None;
13231                let mut buffer_size__ = None;
13232                let mut aligned__ = None;
13233                while let Some(k) = map_.next_key()? {
13234                    match k {
13235                        GeneratedField::LogStoreTable => {
13236                            if log_store_table__.is_some() {
13237                                return Err(serde::de::Error::duplicate_field("logStoreTable"));
13238                            }
13239                            log_store_table__ = map_.next_value()?;
13240                        }
13241                        GeneratedField::PauseDurationMs => {
13242                            if pause_duration_ms__.is_some() {
13243                                return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
13244                            }
13245                            pause_duration_ms__ = 
13246                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13247                            ;
13248                        }
13249                        GeneratedField::BufferSize => {
13250                            if buffer_size__.is_some() {
13251                                return Err(serde::de::Error::duplicate_field("bufferSize"));
13252                            }
13253                            buffer_size__ = 
13254                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13255                            ;
13256                        }
13257                        GeneratedField::Aligned => {
13258                            if aligned__.is_some() {
13259                                return Err(serde::de::Error::duplicate_field("aligned"));
13260                            }
13261                            aligned__ = Some(map_.next_value()?);
13262                        }
13263                    }
13264                }
13265                Ok(SyncLogStoreNode {
13266                    log_store_table: log_store_table__,
13267                    pause_duration_ms: pause_duration_ms__.unwrap_or_default(),
13268                    buffer_size: buffer_size__.unwrap_or_default(),
13269                    aligned: aligned__.unwrap_or_default(),
13270                })
13271            }
13272        }
13273        deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
13274    }
13275}
13276impl serde::Serialize for TemporalJoinNode {
13277    #[allow(deprecated)]
13278    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13279    where
13280        S: serde::Serializer,
13281    {
13282        use serde::ser::SerializeStruct;
13283        let mut len = 0;
13284        if self.join_type != 0 {
13285            len += 1;
13286        }
13287        if !self.left_key.is_empty() {
13288            len += 1;
13289        }
13290        if !self.right_key.is_empty() {
13291            len += 1;
13292        }
13293        if !self.null_safe.is_empty() {
13294            len += 1;
13295        }
13296        if self.condition.is_some() {
13297            len += 1;
13298        }
13299        if !self.output_indices.is_empty() {
13300            len += 1;
13301        }
13302        if self.table_desc.is_some() {
13303            len += 1;
13304        }
13305        if !self.table_output_indices.is_empty() {
13306            len += 1;
13307        }
13308        if self.memo_table.is_some() {
13309            len += 1;
13310        }
13311        if self.is_nested_loop {
13312            len += 1;
13313        }
13314        let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
13315        if self.join_type != 0 {
13316            let v = super::plan_common::JoinType::try_from(self.join_type)
13317                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
13318            struct_ser.serialize_field("joinType", &v)?;
13319        }
13320        if !self.left_key.is_empty() {
13321            struct_ser.serialize_field("leftKey", &self.left_key)?;
13322        }
13323        if !self.right_key.is_empty() {
13324            struct_ser.serialize_field("rightKey", &self.right_key)?;
13325        }
13326        if !self.null_safe.is_empty() {
13327            struct_ser.serialize_field("nullSafe", &self.null_safe)?;
13328        }
13329        if let Some(v) = self.condition.as_ref() {
13330            struct_ser.serialize_field("condition", v)?;
13331        }
13332        if !self.output_indices.is_empty() {
13333            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
13334        }
13335        if let Some(v) = self.table_desc.as_ref() {
13336            struct_ser.serialize_field("tableDesc", v)?;
13337        }
13338        if !self.table_output_indices.is_empty() {
13339            struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
13340        }
13341        if let Some(v) = self.memo_table.as_ref() {
13342            struct_ser.serialize_field("memoTable", v)?;
13343        }
13344        if self.is_nested_loop {
13345            struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
13346        }
13347        struct_ser.end()
13348    }
13349}
13350impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
13351    #[allow(deprecated)]
13352    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13353    where
13354        D: serde::Deserializer<'de>,
13355    {
13356        const FIELDS: &[&str] = &[
13357            "join_type",
13358            "joinType",
13359            "left_key",
13360            "leftKey",
13361            "right_key",
13362            "rightKey",
13363            "null_safe",
13364            "nullSafe",
13365            "condition",
13366            "output_indices",
13367            "outputIndices",
13368            "table_desc",
13369            "tableDesc",
13370            "table_output_indices",
13371            "tableOutputIndices",
13372            "memo_table",
13373            "memoTable",
13374            "is_nested_loop",
13375            "isNestedLoop",
13376        ];
13377
13378        #[allow(clippy::enum_variant_names)]
13379        enum GeneratedField {
13380            JoinType,
13381            LeftKey,
13382            RightKey,
13383            NullSafe,
13384            Condition,
13385            OutputIndices,
13386            TableDesc,
13387            TableOutputIndices,
13388            MemoTable,
13389            IsNestedLoop,
13390        }
13391        impl<'de> serde::Deserialize<'de> for GeneratedField {
13392            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13393            where
13394                D: serde::Deserializer<'de>,
13395            {
13396                struct GeneratedVisitor;
13397
13398                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13399                    type Value = GeneratedField;
13400
13401                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13402                        write!(formatter, "expected one of: {:?}", &FIELDS)
13403                    }
13404
13405                    #[allow(unused_variables)]
13406                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13407                    where
13408                        E: serde::de::Error,
13409                    {
13410                        match value {
13411                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
13412                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
13413                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
13414                            "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
13415                            "condition" => Ok(GeneratedField::Condition),
13416                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
13417                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
13418                            "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
13419                            "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
13420                            "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
13421                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13422                        }
13423                    }
13424                }
13425                deserializer.deserialize_identifier(GeneratedVisitor)
13426            }
13427        }
13428        struct GeneratedVisitor;
13429        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13430            type Value = TemporalJoinNode;
13431
13432            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13433                formatter.write_str("struct stream_plan.TemporalJoinNode")
13434            }
13435
13436            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
13437                where
13438                    V: serde::de::MapAccess<'de>,
13439            {
13440                let mut join_type__ = None;
13441                let mut left_key__ = None;
13442                let mut right_key__ = None;
13443                let mut null_safe__ = None;
13444                let mut condition__ = None;
13445                let mut output_indices__ = None;
13446                let mut table_desc__ = None;
13447                let mut table_output_indices__ = None;
13448                let mut memo_table__ = None;
13449                let mut is_nested_loop__ = None;
13450                while let Some(k) = map_.next_key()? {
13451                    match k {
13452                        GeneratedField::JoinType => {
13453                            if join_type__.is_some() {
13454                                return Err(serde::de::Error::duplicate_field("joinType"));
13455                            }
13456                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
13457                        }
13458                        GeneratedField::LeftKey => {
13459                            if left_key__.is_some() {
13460                                return Err(serde::de::Error::duplicate_field("leftKey"));
13461                            }
13462                            left_key__ = 
13463                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13464                                    .into_iter().map(|x| x.0).collect())
13465                            ;
13466                        }
13467                        GeneratedField::RightKey => {
13468                            if right_key__.is_some() {
13469                                return Err(serde::de::Error::duplicate_field("rightKey"));
13470                            }
13471                            right_key__ = 
13472                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13473                                    .into_iter().map(|x| x.0).collect())
13474                            ;
13475                        }
13476                        GeneratedField::NullSafe => {
13477                            if null_safe__.is_some() {
13478                                return Err(serde::de::Error::duplicate_field("nullSafe"));
13479                            }
13480                            null_safe__ = Some(map_.next_value()?);
13481                        }
13482                        GeneratedField::Condition => {
13483                            if condition__.is_some() {
13484                                return Err(serde::de::Error::duplicate_field("condition"));
13485                            }
13486                            condition__ = map_.next_value()?;
13487                        }
13488                        GeneratedField::OutputIndices => {
13489                            if output_indices__.is_some() {
13490                                return Err(serde::de::Error::duplicate_field("outputIndices"));
13491                            }
13492                            output_indices__ = 
13493                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13494                                    .into_iter().map(|x| x.0).collect())
13495                            ;
13496                        }
13497                        GeneratedField::TableDesc => {
13498                            if table_desc__.is_some() {
13499                                return Err(serde::de::Error::duplicate_field("tableDesc"));
13500                            }
13501                            table_desc__ = map_.next_value()?;
13502                        }
13503                        GeneratedField::TableOutputIndices => {
13504                            if table_output_indices__.is_some() {
13505                                return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
13506                            }
13507                            table_output_indices__ = 
13508                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13509                                    .into_iter().map(|x| x.0).collect())
13510                            ;
13511                        }
13512                        GeneratedField::MemoTable => {
13513                            if memo_table__.is_some() {
13514                                return Err(serde::de::Error::duplicate_field("memoTable"));
13515                            }
13516                            memo_table__ = map_.next_value()?;
13517                        }
13518                        GeneratedField::IsNestedLoop => {
13519                            if is_nested_loop__.is_some() {
13520                                return Err(serde::de::Error::duplicate_field("isNestedLoop"));
13521                            }
13522                            is_nested_loop__ = Some(map_.next_value()?);
13523                        }
13524                    }
13525                }
13526                Ok(TemporalJoinNode {
13527                    join_type: join_type__.unwrap_or_default(),
13528                    left_key: left_key__.unwrap_or_default(),
13529                    right_key: right_key__.unwrap_or_default(),
13530                    null_safe: null_safe__.unwrap_or_default(),
13531                    condition: condition__,
13532                    output_indices: output_indices__.unwrap_or_default(),
13533                    table_desc: table_desc__,
13534                    table_output_indices: table_output_indices__.unwrap_or_default(),
13535                    memo_table: memo_table__,
13536                    is_nested_loop: is_nested_loop__.unwrap_or_default(),
13537                })
13538            }
13539        }
13540        deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
13541    }
13542}
13543impl serde::Serialize for ThrottleMutation {
13544    #[allow(deprecated)]
13545    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13546    where
13547        S: serde::Serializer,
13548    {
13549        use serde::ser::SerializeStruct;
13550        let mut len = 0;
13551        if !self.actor_throttle.is_empty() {
13552            len += 1;
13553        }
13554        let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
13555        if !self.actor_throttle.is_empty() {
13556            struct_ser.serialize_field("actorThrottle", &self.actor_throttle)?;
13557        }
13558        struct_ser.end()
13559    }
13560}
13561impl<'de> serde::Deserialize<'de> for ThrottleMutation {
13562    #[allow(deprecated)]
13563    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13564    where
13565        D: serde::Deserializer<'de>,
13566    {
13567        const FIELDS: &[&str] = &[
13568            "actor_throttle",
13569            "actorThrottle",
13570        ];
13571
13572        #[allow(clippy::enum_variant_names)]
13573        enum GeneratedField {
13574            ActorThrottle,
13575        }
13576        impl<'de> serde::Deserialize<'de> for GeneratedField {
13577            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13578            where
13579                D: serde::Deserializer<'de>,
13580            {
13581                struct GeneratedVisitor;
13582
13583                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13584                    type Value = GeneratedField;
13585
13586                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13587                        write!(formatter, "expected one of: {:?}", &FIELDS)
13588                    }
13589
13590                    #[allow(unused_variables)]
13591                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13592                    where
13593                        E: serde::de::Error,
13594                    {
13595                        match value {
13596                            "actorThrottle" | "actor_throttle" => Ok(GeneratedField::ActorThrottle),
13597                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13598                        }
13599                    }
13600                }
13601                deserializer.deserialize_identifier(GeneratedVisitor)
13602            }
13603        }
13604        struct GeneratedVisitor;
13605        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13606            type Value = ThrottleMutation;
13607
13608            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13609                formatter.write_str("struct stream_plan.ThrottleMutation")
13610            }
13611
13612            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
13613                where
13614                    V: serde::de::MapAccess<'de>,
13615            {
13616                let mut actor_throttle__ = None;
13617                while let Some(k) = map_.next_key()? {
13618                    match k {
13619                        GeneratedField::ActorThrottle => {
13620                            if actor_throttle__.is_some() {
13621                                return Err(serde::de::Error::duplicate_field("actorThrottle"));
13622                            }
13623                            actor_throttle__ = Some(
13624                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
13625                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
13626                            );
13627                        }
13628                    }
13629                }
13630                Ok(ThrottleMutation {
13631                    actor_throttle: actor_throttle__.unwrap_or_default(),
13632                })
13633            }
13634        }
13635        deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
13636    }
13637}
13638impl serde::Serialize for throttle_mutation::RateLimit {
13639    #[allow(deprecated)]
13640    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13641    where
13642        S: serde::Serializer,
13643    {
13644        use serde::ser::SerializeStruct;
13645        let mut len = 0;
13646        if self.rate_limit.is_some() {
13647            len += 1;
13648        }
13649        let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.RateLimit", len)?;
13650        if let Some(v) = self.rate_limit.as_ref() {
13651            struct_ser.serialize_field("rateLimit", v)?;
13652        }
13653        struct_ser.end()
13654    }
13655}
13656impl<'de> serde::Deserialize<'de> for throttle_mutation::RateLimit {
13657    #[allow(deprecated)]
13658    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13659    where
13660        D: serde::Deserializer<'de>,
13661    {
13662        const FIELDS: &[&str] = &[
13663            "rate_limit",
13664            "rateLimit",
13665        ];
13666
13667        #[allow(clippy::enum_variant_names)]
13668        enum GeneratedField {
13669            RateLimit,
13670        }
13671        impl<'de> serde::Deserialize<'de> for GeneratedField {
13672            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13673            where
13674                D: serde::Deserializer<'de>,
13675            {
13676                struct GeneratedVisitor;
13677
13678                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13679                    type Value = GeneratedField;
13680
13681                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13682                        write!(formatter, "expected one of: {:?}", &FIELDS)
13683                    }
13684
13685                    #[allow(unused_variables)]
13686                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13687                    where
13688                        E: serde::de::Error,
13689                    {
13690                        match value {
13691                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13692                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13693                        }
13694                    }
13695                }
13696                deserializer.deserialize_identifier(GeneratedVisitor)
13697            }
13698        }
13699        struct GeneratedVisitor;
13700        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13701            type Value = throttle_mutation::RateLimit;
13702
13703            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13704                formatter.write_str("struct stream_plan.ThrottleMutation.RateLimit")
13705            }
13706
13707            fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::RateLimit, V::Error>
13708                where
13709                    V: serde::de::MapAccess<'de>,
13710            {
13711                let mut rate_limit__ = None;
13712                while let Some(k) = map_.next_key()? {
13713                    match k {
13714                        GeneratedField::RateLimit => {
13715                            if rate_limit__.is_some() {
13716                                return Err(serde::de::Error::duplicate_field("rateLimit"));
13717                            }
13718                            rate_limit__ = 
13719                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13720                            ;
13721                        }
13722                    }
13723                }
13724                Ok(throttle_mutation::RateLimit {
13725                    rate_limit: rate_limit__,
13726                })
13727            }
13728        }
13729        deserializer.deserialize_struct("stream_plan.ThrottleMutation.RateLimit", FIELDS, GeneratedVisitor)
13730    }
13731}
13732impl serde::Serialize for TopNNode {
13733    #[allow(deprecated)]
13734    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13735    where
13736        S: serde::Serializer,
13737    {
13738        use serde::ser::SerializeStruct;
13739        let mut len = 0;
13740        if self.limit != 0 {
13741            len += 1;
13742        }
13743        if self.offset != 0 {
13744            len += 1;
13745        }
13746        if self.table.is_some() {
13747            len += 1;
13748        }
13749        if !self.order_by.is_empty() {
13750            len += 1;
13751        }
13752        if self.with_ties {
13753            len += 1;
13754        }
13755        let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
13756        if self.limit != 0 {
13757            #[allow(clippy::needless_borrow)]
13758            #[allow(clippy::needless_borrows_for_generic_args)]
13759            struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
13760        }
13761        if self.offset != 0 {
13762            #[allow(clippy::needless_borrow)]
13763            #[allow(clippy::needless_borrows_for_generic_args)]
13764            struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
13765        }
13766        if let Some(v) = self.table.as_ref() {
13767            struct_ser.serialize_field("table", v)?;
13768        }
13769        if !self.order_by.is_empty() {
13770            struct_ser.serialize_field("orderBy", &self.order_by)?;
13771        }
13772        if self.with_ties {
13773            struct_ser.serialize_field("withTies", &self.with_ties)?;
13774        }
13775        struct_ser.end()
13776    }
13777}
13778impl<'de> serde::Deserialize<'de> for TopNNode {
13779    #[allow(deprecated)]
13780    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13781    where
13782        D: serde::Deserializer<'de>,
13783    {
13784        const FIELDS: &[&str] = &[
13785            "limit",
13786            "offset",
13787            "table",
13788            "order_by",
13789            "orderBy",
13790            "with_ties",
13791            "withTies",
13792        ];
13793
13794        #[allow(clippy::enum_variant_names)]
13795        enum GeneratedField {
13796            Limit,
13797            Offset,
13798            Table,
13799            OrderBy,
13800            WithTies,
13801        }
13802        impl<'de> serde::Deserialize<'de> for GeneratedField {
13803            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13804            where
13805                D: serde::Deserializer<'de>,
13806            {
13807                struct GeneratedVisitor;
13808
13809                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13810                    type Value = GeneratedField;
13811
13812                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13813                        write!(formatter, "expected one of: {:?}", &FIELDS)
13814                    }
13815
13816                    #[allow(unused_variables)]
13817                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13818                    where
13819                        E: serde::de::Error,
13820                    {
13821                        match value {
13822                            "limit" => Ok(GeneratedField::Limit),
13823                            "offset" => Ok(GeneratedField::Offset),
13824                            "table" => Ok(GeneratedField::Table),
13825                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
13826                            "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
13827                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13828                        }
13829                    }
13830                }
13831                deserializer.deserialize_identifier(GeneratedVisitor)
13832            }
13833        }
13834        struct GeneratedVisitor;
13835        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13836            type Value = TopNNode;
13837
13838            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13839                formatter.write_str("struct stream_plan.TopNNode")
13840            }
13841
13842            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
13843                where
13844                    V: serde::de::MapAccess<'de>,
13845            {
13846                let mut limit__ = None;
13847                let mut offset__ = None;
13848                let mut table__ = None;
13849                let mut order_by__ = None;
13850                let mut with_ties__ = None;
13851                while let Some(k) = map_.next_key()? {
13852                    match k {
13853                        GeneratedField::Limit => {
13854                            if limit__.is_some() {
13855                                return Err(serde::de::Error::duplicate_field("limit"));
13856                            }
13857                            limit__ = 
13858                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13859                            ;
13860                        }
13861                        GeneratedField::Offset => {
13862                            if offset__.is_some() {
13863                                return Err(serde::de::Error::duplicate_field("offset"));
13864                            }
13865                            offset__ = 
13866                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13867                            ;
13868                        }
13869                        GeneratedField::Table => {
13870                            if table__.is_some() {
13871                                return Err(serde::de::Error::duplicate_field("table"));
13872                            }
13873                            table__ = map_.next_value()?;
13874                        }
13875                        GeneratedField::OrderBy => {
13876                            if order_by__.is_some() {
13877                                return Err(serde::de::Error::duplicate_field("orderBy"));
13878                            }
13879                            order_by__ = Some(map_.next_value()?);
13880                        }
13881                        GeneratedField::WithTies => {
13882                            if with_ties__.is_some() {
13883                                return Err(serde::de::Error::duplicate_field("withTies"));
13884                            }
13885                            with_ties__ = Some(map_.next_value()?);
13886                        }
13887                    }
13888                }
13889                Ok(TopNNode {
13890                    limit: limit__.unwrap_or_default(),
13891                    offset: offset__.unwrap_or_default(),
13892                    table: table__,
13893                    order_by: order_by__.unwrap_or_default(),
13894                    with_ties: with_ties__.unwrap_or_default(),
13895                })
13896            }
13897        }
13898        deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
13899    }
13900}
13901impl serde::Serialize for UnionNode {
13902    #[allow(deprecated)]
13903    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13904    where
13905        S: serde::Serializer,
13906    {
13907        use serde::ser::SerializeStruct;
13908        let len = 0;
13909        let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
13910        struct_ser.end()
13911    }
13912}
13913impl<'de> serde::Deserialize<'de> for UnionNode {
13914    #[allow(deprecated)]
13915    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13916    where
13917        D: serde::Deserializer<'de>,
13918    {
13919        const FIELDS: &[&str] = &[
13920        ];
13921
13922        #[allow(clippy::enum_variant_names)]
13923        enum GeneratedField {
13924        }
13925        impl<'de> serde::Deserialize<'de> for GeneratedField {
13926            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13927            where
13928                D: serde::Deserializer<'de>,
13929            {
13930                struct GeneratedVisitor;
13931
13932                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13933                    type Value = GeneratedField;
13934
13935                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13936                        write!(formatter, "expected one of: {:?}", &FIELDS)
13937                    }
13938
13939                    #[allow(unused_variables)]
13940                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13941                    where
13942                        E: serde::de::Error,
13943                    {
13944                            Err(serde::de::Error::unknown_field(value, FIELDS))
13945                    }
13946                }
13947                deserializer.deserialize_identifier(GeneratedVisitor)
13948            }
13949        }
13950        struct GeneratedVisitor;
13951        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13952            type Value = UnionNode;
13953
13954            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13955                formatter.write_str("struct stream_plan.UnionNode")
13956            }
13957
13958            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
13959                where
13960                    V: serde::de::MapAccess<'de>,
13961            {
13962                while map_.next_key::<GeneratedField>()?.is_some() {
13963                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
13964                }
13965                Ok(UnionNode {
13966                })
13967            }
13968        }
13969        deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
13970    }
13971}
13972impl serde::Serialize for UpdateMutation {
13973    #[allow(deprecated)]
13974    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13975    where
13976        S: serde::Serializer,
13977    {
13978        use serde::ser::SerializeStruct;
13979        let mut len = 0;
13980        if !self.dispatcher_update.is_empty() {
13981            len += 1;
13982        }
13983        if !self.merge_update.is_empty() {
13984            len += 1;
13985        }
13986        if !self.actor_vnode_bitmap_update.is_empty() {
13987            len += 1;
13988        }
13989        if !self.dropped_actors.is_empty() {
13990            len += 1;
13991        }
13992        if !self.actor_splits.is_empty() {
13993            len += 1;
13994        }
13995        if !self.actor_new_dispatchers.is_empty() {
13996            len += 1;
13997        }
13998        let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
13999        if !self.dispatcher_update.is_empty() {
14000            struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
14001        }
14002        if !self.merge_update.is_empty() {
14003            struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
14004        }
14005        if !self.actor_vnode_bitmap_update.is_empty() {
14006            struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
14007        }
14008        if !self.dropped_actors.is_empty() {
14009            struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
14010        }
14011        if !self.actor_splits.is_empty() {
14012            struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
14013        }
14014        if !self.actor_new_dispatchers.is_empty() {
14015            struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
14016        }
14017        struct_ser.end()
14018    }
14019}
14020impl<'de> serde::Deserialize<'de> for UpdateMutation {
14021    #[allow(deprecated)]
14022    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14023    where
14024        D: serde::Deserializer<'de>,
14025    {
14026        const FIELDS: &[&str] = &[
14027            "dispatcher_update",
14028            "dispatcherUpdate",
14029            "merge_update",
14030            "mergeUpdate",
14031            "actor_vnode_bitmap_update",
14032            "actorVnodeBitmapUpdate",
14033            "dropped_actors",
14034            "droppedActors",
14035            "actor_splits",
14036            "actorSplits",
14037            "actor_new_dispatchers",
14038            "actorNewDispatchers",
14039        ];
14040
14041        #[allow(clippy::enum_variant_names)]
14042        enum GeneratedField {
14043            DispatcherUpdate,
14044            MergeUpdate,
14045            ActorVnodeBitmapUpdate,
14046            DroppedActors,
14047            ActorSplits,
14048            ActorNewDispatchers,
14049        }
14050        impl<'de> serde::Deserialize<'de> for GeneratedField {
14051            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14052            where
14053                D: serde::Deserializer<'de>,
14054            {
14055                struct GeneratedVisitor;
14056
14057                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14058                    type Value = GeneratedField;
14059
14060                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14061                        write!(formatter, "expected one of: {:?}", &FIELDS)
14062                    }
14063
14064                    #[allow(unused_variables)]
14065                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14066                    where
14067                        E: serde::de::Error,
14068                    {
14069                        match value {
14070                            "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
14071                            "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
14072                            "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
14073                            "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
14074                            "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
14075                            "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
14076                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14077                        }
14078                    }
14079                }
14080                deserializer.deserialize_identifier(GeneratedVisitor)
14081            }
14082        }
14083        struct GeneratedVisitor;
14084        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14085            type Value = UpdateMutation;
14086
14087            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14088                formatter.write_str("struct stream_plan.UpdateMutation")
14089            }
14090
14091            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
14092                where
14093                    V: serde::de::MapAccess<'de>,
14094            {
14095                let mut dispatcher_update__ = None;
14096                let mut merge_update__ = None;
14097                let mut actor_vnode_bitmap_update__ = None;
14098                let mut dropped_actors__ = None;
14099                let mut actor_splits__ = None;
14100                let mut actor_new_dispatchers__ = None;
14101                while let Some(k) = map_.next_key()? {
14102                    match k {
14103                        GeneratedField::DispatcherUpdate => {
14104                            if dispatcher_update__.is_some() {
14105                                return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
14106                            }
14107                            dispatcher_update__ = Some(map_.next_value()?);
14108                        }
14109                        GeneratedField::MergeUpdate => {
14110                            if merge_update__.is_some() {
14111                                return Err(serde::de::Error::duplicate_field("mergeUpdate"));
14112                            }
14113                            merge_update__ = Some(map_.next_value()?);
14114                        }
14115                        GeneratedField::ActorVnodeBitmapUpdate => {
14116                            if actor_vnode_bitmap_update__.is_some() {
14117                                return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
14118                            }
14119                            actor_vnode_bitmap_update__ = Some(
14120                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14121                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
14122                            );
14123                        }
14124                        GeneratedField::DroppedActors => {
14125                            if dropped_actors__.is_some() {
14126                                return Err(serde::de::Error::duplicate_field("droppedActors"));
14127                            }
14128                            dropped_actors__ = 
14129                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14130                                    .into_iter().map(|x| x.0).collect())
14131                            ;
14132                        }
14133                        GeneratedField::ActorSplits => {
14134                            if actor_splits__.is_some() {
14135                                return Err(serde::de::Error::duplicate_field("actorSplits"));
14136                            }
14137                            actor_splits__ = Some(
14138                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14139                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
14140                            );
14141                        }
14142                        GeneratedField::ActorNewDispatchers => {
14143                            if actor_new_dispatchers__.is_some() {
14144                                return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
14145                            }
14146                            actor_new_dispatchers__ = Some(
14147                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14148                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
14149                            );
14150                        }
14151                    }
14152                }
14153                Ok(UpdateMutation {
14154                    dispatcher_update: dispatcher_update__.unwrap_or_default(),
14155                    merge_update: merge_update__.unwrap_or_default(),
14156                    actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
14157                    dropped_actors: dropped_actors__.unwrap_or_default(),
14158                    actor_splits: actor_splits__.unwrap_or_default(),
14159                    actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
14160                })
14161            }
14162        }
14163        deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
14164    }
14165}
14166impl serde::Serialize for update_mutation::DispatcherUpdate {
14167    #[allow(deprecated)]
14168    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14169    where
14170        S: serde::Serializer,
14171    {
14172        use serde::ser::SerializeStruct;
14173        let mut len = 0;
14174        if self.actor_id != 0 {
14175            len += 1;
14176        }
14177        if self.dispatcher_id != 0 {
14178            len += 1;
14179        }
14180        if self.hash_mapping.is_some() {
14181            len += 1;
14182        }
14183        if !self.added_downstream_actor_id.is_empty() {
14184            len += 1;
14185        }
14186        if !self.removed_downstream_actor_id.is_empty() {
14187            len += 1;
14188        }
14189        let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
14190        if self.actor_id != 0 {
14191            struct_ser.serialize_field("actorId", &self.actor_id)?;
14192        }
14193        if self.dispatcher_id != 0 {
14194            #[allow(clippy::needless_borrow)]
14195            #[allow(clippy::needless_borrows_for_generic_args)]
14196            struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
14197        }
14198        if let Some(v) = self.hash_mapping.as_ref() {
14199            struct_ser.serialize_field("hashMapping", v)?;
14200        }
14201        if !self.added_downstream_actor_id.is_empty() {
14202            struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
14203        }
14204        if !self.removed_downstream_actor_id.is_empty() {
14205            struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
14206        }
14207        struct_ser.end()
14208    }
14209}
14210impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
14211    #[allow(deprecated)]
14212    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14213    where
14214        D: serde::Deserializer<'de>,
14215    {
14216        const FIELDS: &[&str] = &[
14217            "actor_id",
14218            "actorId",
14219            "dispatcher_id",
14220            "dispatcherId",
14221            "hash_mapping",
14222            "hashMapping",
14223            "added_downstream_actor_id",
14224            "addedDownstreamActorId",
14225            "removed_downstream_actor_id",
14226            "removedDownstreamActorId",
14227        ];
14228
14229        #[allow(clippy::enum_variant_names)]
14230        enum GeneratedField {
14231            ActorId,
14232            DispatcherId,
14233            HashMapping,
14234            AddedDownstreamActorId,
14235            RemovedDownstreamActorId,
14236        }
14237        impl<'de> serde::Deserialize<'de> for GeneratedField {
14238            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14239            where
14240                D: serde::Deserializer<'de>,
14241            {
14242                struct GeneratedVisitor;
14243
14244                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14245                    type Value = GeneratedField;
14246
14247                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14248                        write!(formatter, "expected one of: {:?}", &FIELDS)
14249                    }
14250
14251                    #[allow(unused_variables)]
14252                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14253                    where
14254                        E: serde::de::Error,
14255                    {
14256                        match value {
14257                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
14258                            "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
14259                            "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
14260                            "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
14261                            "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
14262                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14263                        }
14264                    }
14265                }
14266                deserializer.deserialize_identifier(GeneratedVisitor)
14267            }
14268        }
14269        struct GeneratedVisitor;
14270        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14271            type Value = update_mutation::DispatcherUpdate;
14272
14273            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14274                formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
14275            }
14276
14277            fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
14278                where
14279                    V: serde::de::MapAccess<'de>,
14280            {
14281                let mut actor_id__ = None;
14282                let mut dispatcher_id__ = None;
14283                let mut hash_mapping__ = None;
14284                let mut added_downstream_actor_id__ = None;
14285                let mut removed_downstream_actor_id__ = None;
14286                while let Some(k) = map_.next_key()? {
14287                    match k {
14288                        GeneratedField::ActorId => {
14289                            if actor_id__.is_some() {
14290                                return Err(serde::de::Error::duplicate_field("actorId"));
14291                            }
14292                            actor_id__ = 
14293                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14294                            ;
14295                        }
14296                        GeneratedField::DispatcherId => {
14297                            if dispatcher_id__.is_some() {
14298                                return Err(serde::de::Error::duplicate_field("dispatcherId"));
14299                            }
14300                            dispatcher_id__ = 
14301                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14302                            ;
14303                        }
14304                        GeneratedField::HashMapping => {
14305                            if hash_mapping__.is_some() {
14306                                return Err(serde::de::Error::duplicate_field("hashMapping"));
14307                            }
14308                            hash_mapping__ = map_.next_value()?;
14309                        }
14310                        GeneratedField::AddedDownstreamActorId => {
14311                            if added_downstream_actor_id__.is_some() {
14312                                return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
14313                            }
14314                            added_downstream_actor_id__ = 
14315                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14316                                    .into_iter().map(|x| x.0).collect())
14317                            ;
14318                        }
14319                        GeneratedField::RemovedDownstreamActorId => {
14320                            if removed_downstream_actor_id__.is_some() {
14321                                return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
14322                            }
14323                            removed_downstream_actor_id__ = 
14324                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14325                                    .into_iter().map(|x| x.0).collect())
14326                            ;
14327                        }
14328                    }
14329                }
14330                Ok(update_mutation::DispatcherUpdate {
14331                    actor_id: actor_id__.unwrap_or_default(),
14332                    dispatcher_id: dispatcher_id__.unwrap_or_default(),
14333                    hash_mapping: hash_mapping__,
14334                    added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
14335                    removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
14336                })
14337            }
14338        }
14339        deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
14340    }
14341}
14342impl serde::Serialize for update_mutation::MergeUpdate {
14343    #[allow(deprecated)]
14344    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14345    where
14346        S: serde::Serializer,
14347    {
14348        use serde::ser::SerializeStruct;
14349        let mut len = 0;
14350        if self.actor_id != 0 {
14351            len += 1;
14352        }
14353        if self.upstream_fragment_id != 0 {
14354            len += 1;
14355        }
14356        if self.new_upstream_fragment_id.is_some() {
14357            len += 1;
14358        }
14359        if !self.added_upstream_actors.is_empty() {
14360            len += 1;
14361        }
14362        if !self.removed_upstream_actor_id.is_empty() {
14363            len += 1;
14364        }
14365        let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
14366        if self.actor_id != 0 {
14367            struct_ser.serialize_field("actorId", &self.actor_id)?;
14368        }
14369        if self.upstream_fragment_id != 0 {
14370            struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
14371        }
14372        if let Some(v) = self.new_upstream_fragment_id.as_ref() {
14373            struct_ser.serialize_field("newUpstreamFragmentId", v)?;
14374        }
14375        if !self.added_upstream_actors.is_empty() {
14376            struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
14377        }
14378        if !self.removed_upstream_actor_id.is_empty() {
14379            struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
14380        }
14381        struct_ser.end()
14382    }
14383}
14384impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
14385    #[allow(deprecated)]
14386    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14387    where
14388        D: serde::Deserializer<'de>,
14389    {
14390        const FIELDS: &[&str] = &[
14391            "actor_id",
14392            "actorId",
14393            "upstream_fragment_id",
14394            "upstreamFragmentId",
14395            "new_upstream_fragment_id",
14396            "newUpstreamFragmentId",
14397            "added_upstream_actors",
14398            "addedUpstreamActors",
14399            "removed_upstream_actor_id",
14400            "removedUpstreamActorId",
14401        ];
14402
14403        #[allow(clippy::enum_variant_names)]
14404        enum GeneratedField {
14405            ActorId,
14406            UpstreamFragmentId,
14407            NewUpstreamFragmentId,
14408            AddedUpstreamActors,
14409            RemovedUpstreamActorId,
14410        }
14411        impl<'de> serde::Deserialize<'de> for GeneratedField {
14412            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14413            where
14414                D: serde::Deserializer<'de>,
14415            {
14416                struct GeneratedVisitor;
14417
14418                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14419                    type Value = GeneratedField;
14420
14421                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14422                        write!(formatter, "expected one of: {:?}", &FIELDS)
14423                    }
14424
14425                    #[allow(unused_variables)]
14426                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14427                    where
14428                        E: serde::de::Error,
14429                    {
14430                        match value {
14431                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
14432                            "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
14433                            "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
14434                            "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
14435                            "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
14436                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14437                        }
14438                    }
14439                }
14440                deserializer.deserialize_identifier(GeneratedVisitor)
14441            }
14442        }
14443        struct GeneratedVisitor;
14444        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14445            type Value = update_mutation::MergeUpdate;
14446
14447            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14448                formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
14449            }
14450
14451            fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
14452                where
14453                    V: serde::de::MapAccess<'de>,
14454            {
14455                let mut actor_id__ = None;
14456                let mut upstream_fragment_id__ = None;
14457                let mut new_upstream_fragment_id__ = None;
14458                let mut added_upstream_actors__ = None;
14459                let mut removed_upstream_actor_id__ = None;
14460                while let Some(k) = map_.next_key()? {
14461                    match k {
14462                        GeneratedField::ActorId => {
14463                            if actor_id__.is_some() {
14464                                return Err(serde::de::Error::duplicate_field("actorId"));
14465                            }
14466                            actor_id__ = 
14467                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14468                            ;
14469                        }
14470                        GeneratedField::UpstreamFragmentId => {
14471                            if upstream_fragment_id__.is_some() {
14472                                return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
14473                            }
14474                            upstream_fragment_id__ = 
14475                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14476                            ;
14477                        }
14478                        GeneratedField::NewUpstreamFragmentId => {
14479                            if new_upstream_fragment_id__.is_some() {
14480                                return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
14481                            }
14482                            new_upstream_fragment_id__ = 
14483                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14484                            ;
14485                        }
14486                        GeneratedField::AddedUpstreamActors => {
14487                            if added_upstream_actors__.is_some() {
14488                                return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
14489                            }
14490                            added_upstream_actors__ = Some(map_.next_value()?);
14491                        }
14492                        GeneratedField::RemovedUpstreamActorId => {
14493                            if removed_upstream_actor_id__.is_some() {
14494                                return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
14495                            }
14496                            removed_upstream_actor_id__ = 
14497                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14498                                    .into_iter().map(|x| x.0).collect())
14499                            ;
14500                        }
14501                    }
14502                }
14503                Ok(update_mutation::MergeUpdate {
14504                    actor_id: actor_id__.unwrap_or_default(),
14505                    upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
14506                    new_upstream_fragment_id: new_upstream_fragment_id__,
14507                    added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
14508                    removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
14509                })
14510            }
14511        }
14512        deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
14513    }
14514}
14515impl serde::Serialize for ValuesNode {
14516    #[allow(deprecated)]
14517    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14518    where
14519        S: serde::Serializer,
14520    {
14521        use serde::ser::SerializeStruct;
14522        let mut len = 0;
14523        if !self.tuples.is_empty() {
14524            len += 1;
14525        }
14526        if !self.fields.is_empty() {
14527            len += 1;
14528        }
14529        let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
14530        if !self.tuples.is_empty() {
14531            struct_ser.serialize_field("tuples", &self.tuples)?;
14532        }
14533        if !self.fields.is_empty() {
14534            struct_ser.serialize_field("fields", &self.fields)?;
14535        }
14536        struct_ser.end()
14537    }
14538}
14539impl<'de> serde::Deserialize<'de> for ValuesNode {
14540    #[allow(deprecated)]
14541    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14542    where
14543        D: serde::Deserializer<'de>,
14544    {
14545        const FIELDS: &[&str] = &[
14546            "tuples",
14547            "fields",
14548        ];
14549
14550        #[allow(clippy::enum_variant_names)]
14551        enum GeneratedField {
14552            Tuples,
14553            Fields,
14554        }
14555        impl<'de> serde::Deserialize<'de> for GeneratedField {
14556            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14557            where
14558                D: serde::Deserializer<'de>,
14559            {
14560                struct GeneratedVisitor;
14561
14562                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14563                    type Value = GeneratedField;
14564
14565                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14566                        write!(formatter, "expected one of: {:?}", &FIELDS)
14567                    }
14568
14569                    #[allow(unused_variables)]
14570                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14571                    where
14572                        E: serde::de::Error,
14573                    {
14574                        match value {
14575                            "tuples" => Ok(GeneratedField::Tuples),
14576                            "fields" => Ok(GeneratedField::Fields),
14577                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14578                        }
14579                    }
14580                }
14581                deserializer.deserialize_identifier(GeneratedVisitor)
14582            }
14583        }
14584        struct GeneratedVisitor;
14585        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14586            type Value = ValuesNode;
14587
14588            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14589                formatter.write_str("struct stream_plan.ValuesNode")
14590            }
14591
14592            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
14593                where
14594                    V: serde::de::MapAccess<'de>,
14595            {
14596                let mut tuples__ = None;
14597                let mut fields__ = None;
14598                while let Some(k) = map_.next_key()? {
14599                    match k {
14600                        GeneratedField::Tuples => {
14601                            if tuples__.is_some() {
14602                                return Err(serde::de::Error::duplicate_field("tuples"));
14603                            }
14604                            tuples__ = Some(map_.next_value()?);
14605                        }
14606                        GeneratedField::Fields => {
14607                            if fields__.is_some() {
14608                                return Err(serde::de::Error::duplicate_field("fields"));
14609                            }
14610                            fields__ = Some(map_.next_value()?);
14611                        }
14612                    }
14613                }
14614                Ok(ValuesNode {
14615                    tuples: tuples__.unwrap_or_default(),
14616                    fields: fields__.unwrap_or_default(),
14617                })
14618            }
14619        }
14620        deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
14621    }
14622}
14623impl serde::Serialize for values_node::ExprTuple {
14624    #[allow(deprecated)]
14625    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14626    where
14627        S: serde::Serializer,
14628    {
14629        use serde::ser::SerializeStruct;
14630        let mut len = 0;
14631        if !self.cells.is_empty() {
14632            len += 1;
14633        }
14634        let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
14635        if !self.cells.is_empty() {
14636            struct_ser.serialize_field("cells", &self.cells)?;
14637        }
14638        struct_ser.end()
14639    }
14640}
14641impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
14642    #[allow(deprecated)]
14643    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14644    where
14645        D: serde::Deserializer<'de>,
14646    {
14647        const FIELDS: &[&str] = &[
14648            "cells",
14649        ];
14650
14651        #[allow(clippy::enum_variant_names)]
14652        enum GeneratedField {
14653            Cells,
14654        }
14655        impl<'de> serde::Deserialize<'de> for GeneratedField {
14656            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14657            where
14658                D: serde::Deserializer<'de>,
14659            {
14660                struct GeneratedVisitor;
14661
14662                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14663                    type Value = GeneratedField;
14664
14665                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14666                        write!(formatter, "expected one of: {:?}", &FIELDS)
14667                    }
14668
14669                    #[allow(unused_variables)]
14670                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14671                    where
14672                        E: serde::de::Error,
14673                    {
14674                        match value {
14675                            "cells" => Ok(GeneratedField::Cells),
14676                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14677                        }
14678                    }
14679                }
14680                deserializer.deserialize_identifier(GeneratedVisitor)
14681            }
14682        }
14683        struct GeneratedVisitor;
14684        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14685            type Value = values_node::ExprTuple;
14686
14687            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14688                formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
14689            }
14690
14691            fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
14692                where
14693                    V: serde::de::MapAccess<'de>,
14694            {
14695                let mut cells__ = None;
14696                while let Some(k) = map_.next_key()? {
14697                    match k {
14698                        GeneratedField::Cells => {
14699                            if cells__.is_some() {
14700                                return Err(serde::de::Error::duplicate_field("cells"));
14701                            }
14702                            cells__ = Some(map_.next_value()?);
14703                        }
14704                    }
14705                }
14706                Ok(values_node::ExprTuple {
14707                    cells: cells__.unwrap_or_default(),
14708                })
14709            }
14710        }
14711        deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
14712    }
14713}
14714impl serde::Serialize for Watermark {
14715    #[allow(deprecated)]
14716    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14717    where
14718        S: serde::Serializer,
14719    {
14720        use serde::ser::SerializeStruct;
14721        let mut len = 0;
14722        if self.column.is_some() {
14723            len += 1;
14724        }
14725        if self.val.is_some() {
14726            len += 1;
14727        }
14728        let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
14729        if let Some(v) = self.column.as_ref() {
14730            struct_ser.serialize_field("column", v)?;
14731        }
14732        if let Some(v) = self.val.as_ref() {
14733            struct_ser.serialize_field("val", v)?;
14734        }
14735        struct_ser.end()
14736    }
14737}
14738impl<'de> serde::Deserialize<'de> for Watermark {
14739    #[allow(deprecated)]
14740    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14741    where
14742        D: serde::Deserializer<'de>,
14743    {
14744        const FIELDS: &[&str] = &[
14745            "column",
14746            "val",
14747        ];
14748
14749        #[allow(clippy::enum_variant_names)]
14750        enum GeneratedField {
14751            Column,
14752            Val,
14753        }
14754        impl<'de> serde::Deserialize<'de> for GeneratedField {
14755            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14756            where
14757                D: serde::Deserializer<'de>,
14758            {
14759                struct GeneratedVisitor;
14760
14761                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14762                    type Value = GeneratedField;
14763
14764                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14765                        write!(formatter, "expected one of: {:?}", &FIELDS)
14766                    }
14767
14768                    #[allow(unused_variables)]
14769                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14770                    where
14771                        E: serde::de::Error,
14772                    {
14773                        match value {
14774                            "column" => Ok(GeneratedField::Column),
14775                            "val" => Ok(GeneratedField::Val),
14776                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14777                        }
14778                    }
14779                }
14780                deserializer.deserialize_identifier(GeneratedVisitor)
14781            }
14782        }
14783        struct GeneratedVisitor;
14784        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14785            type Value = Watermark;
14786
14787            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14788                formatter.write_str("struct stream_plan.Watermark")
14789            }
14790
14791            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
14792                where
14793                    V: serde::de::MapAccess<'de>,
14794            {
14795                let mut column__ = None;
14796                let mut val__ = None;
14797                while let Some(k) = map_.next_key()? {
14798                    match k {
14799                        GeneratedField::Column => {
14800                            if column__.is_some() {
14801                                return Err(serde::de::Error::duplicate_field("column"));
14802                            }
14803                            column__ = map_.next_value()?;
14804                        }
14805                        GeneratedField::Val => {
14806                            if val__.is_some() {
14807                                return Err(serde::de::Error::duplicate_field("val"));
14808                            }
14809                            val__ = map_.next_value()?;
14810                        }
14811                    }
14812                }
14813                Ok(Watermark {
14814                    column: column__,
14815                    val: val__,
14816                })
14817            }
14818        }
14819        deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
14820    }
14821}
14822impl serde::Serialize for WatermarkFilterNode {
14823    #[allow(deprecated)]
14824    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14825    where
14826        S: serde::Serializer,
14827    {
14828        use serde::ser::SerializeStruct;
14829        let mut len = 0;
14830        if !self.watermark_descs.is_empty() {
14831            len += 1;
14832        }
14833        if !self.tables.is_empty() {
14834            len += 1;
14835        }
14836        let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
14837        if !self.watermark_descs.is_empty() {
14838            struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
14839        }
14840        if !self.tables.is_empty() {
14841            struct_ser.serialize_field("tables", &self.tables)?;
14842        }
14843        struct_ser.end()
14844    }
14845}
14846impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
14847    #[allow(deprecated)]
14848    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14849    where
14850        D: serde::Deserializer<'de>,
14851    {
14852        const FIELDS: &[&str] = &[
14853            "watermark_descs",
14854            "watermarkDescs",
14855            "tables",
14856        ];
14857
14858        #[allow(clippy::enum_variant_names)]
14859        enum GeneratedField {
14860            WatermarkDescs,
14861            Tables,
14862        }
14863        impl<'de> serde::Deserialize<'de> for GeneratedField {
14864            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14865            where
14866                D: serde::Deserializer<'de>,
14867            {
14868                struct GeneratedVisitor;
14869
14870                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14871                    type Value = GeneratedField;
14872
14873                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14874                        write!(formatter, "expected one of: {:?}", &FIELDS)
14875                    }
14876
14877                    #[allow(unused_variables)]
14878                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14879                    where
14880                        E: serde::de::Error,
14881                    {
14882                        match value {
14883                            "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
14884                            "tables" => Ok(GeneratedField::Tables),
14885                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14886                        }
14887                    }
14888                }
14889                deserializer.deserialize_identifier(GeneratedVisitor)
14890            }
14891        }
14892        struct GeneratedVisitor;
14893        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14894            type Value = WatermarkFilterNode;
14895
14896            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14897                formatter.write_str("struct stream_plan.WatermarkFilterNode")
14898            }
14899
14900            fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
14901                where
14902                    V: serde::de::MapAccess<'de>,
14903            {
14904                let mut watermark_descs__ = None;
14905                let mut tables__ = None;
14906                while let Some(k) = map_.next_key()? {
14907                    match k {
14908                        GeneratedField::WatermarkDescs => {
14909                            if watermark_descs__.is_some() {
14910                                return Err(serde::de::Error::duplicate_field("watermarkDescs"));
14911                            }
14912                            watermark_descs__ = Some(map_.next_value()?);
14913                        }
14914                        GeneratedField::Tables => {
14915                            if tables__.is_some() {
14916                                return Err(serde::de::Error::duplicate_field("tables"));
14917                            }
14918                            tables__ = Some(map_.next_value()?);
14919                        }
14920                    }
14921                }
14922                Ok(WatermarkFilterNode {
14923                    watermark_descs: watermark_descs__.unwrap_or_default(),
14924                    tables: tables__.unwrap_or_default(),
14925                })
14926            }
14927        }
14928        deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
14929    }
14930}