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        if self.actor_cdc_table_snapshot_splits.is_some() {
144            len += 1;
145        }
146        if !self.new_upstream_sinks.is_empty() {
147            len += 1;
148        }
149        let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation", len)?;
150        if !self.actor_dispatchers.is_empty() {
151            struct_ser.serialize_field("actorDispatchers", &self.actor_dispatchers)?;
152        }
153        if !self.added_actors.is_empty() {
154            struct_ser.serialize_field("addedActors", &self.added_actors)?;
155        }
156        if !self.actor_splits.is_empty() {
157            struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
158        }
159        if self.pause {
160            struct_ser.serialize_field("pause", &self.pause)?;
161        }
162        if !self.subscriptions_to_add.is_empty() {
163            struct_ser.serialize_field("subscriptionsToAdd", &self.subscriptions_to_add)?;
164        }
165        if !self.backfill_nodes_to_pause.is_empty() {
166            struct_ser.serialize_field("backfillNodesToPause", &self.backfill_nodes_to_pause)?;
167        }
168        if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
169            struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
170        }
171        if !self.new_upstream_sinks.is_empty() {
172            struct_ser.serialize_field("newUpstreamSinks", &self.new_upstream_sinks)?;
173        }
174        struct_ser.end()
175    }
176}
177impl<'de> serde::Deserialize<'de> for AddMutation {
178    #[allow(deprecated)]
179    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
180    where
181        D: serde::Deserializer<'de>,
182    {
183        const FIELDS: &[&str] = &[
184            "actor_dispatchers",
185            "actorDispatchers",
186            "added_actors",
187            "addedActors",
188            "actor_splits",
189            "actorSplits",
190            "pause",
191            "subscriptions_to_add",
192            "subscriptionsToAdd",
193            "backfill_nodes_to_pause",
194            "backfillNodesToPause",
195            "actor_cdc_table_snapshot_splits",
196            "actorCdcTableSnapshotSplits",
197            "new_upstream_sinks",
198            "newUpstreamSinks",
199        ];
200
201        #[allow(clippy::enum_variant_names)]
202        enum GeneratedField {
203            ActorDispatchers,
204            AddedActors,
205            ActorSplits,
206            Pause,
207            SubscriptionsToAdd,
208            BackfillNodesToPause,
209            ActorCdcTableSnapshotSplits,
210            NewUpstreamSinks,
211        }
212        impl<'de> serde::Deserialize<'de> for GeneratedField {
213            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
214            where
215                D: serde::Deserializer<'de>,
216            {
217                struct GeneratedVisitor;
218
219                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
220                    type Value = GeneratedField;
221
222                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
223                        write!(formatter, "expected one of: {:?}", &FIELDS)
224                    }
225
226                    #[allow(unused_variables)]
227                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
228                    where
229                        E: serde::de::Error,
230                    {
231                        match value {
232                            "actorDispatchers" | "actor_dispatchers" => Ok(GeneratedField::ActorDispatchers),
233                            "addedActors" | "added_actors" => Ok(GeneratedField::AddedActors),
234                            "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
235                            "pause" => Ok(GeneratedField::Pause),
236                            "subscriptionsToAdd" | "subscriptions_to_add" => Ok(GeneratedField::SubscriptionsToAdd),
237                            "backfillNodesToPause" | "backfill_nodes_to_pause" => Ok(GeneratedField::BackfillNodesToPause),
238                            "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
239                            "newUpstreamSinks" | "new_upstream_sinks" => Ok(GeneratedField::NewUpstreamSinks),
240                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
241                        }
242                    }
243                }
244                deserializer.deserialize_identifier(GeneratedVisitor)
245            }
246        }
247        struct GeneratedVisitor;
248        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
249            type Value = AddMutation;
250
251            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
252                formatter.write_str("struct stream_plan.AddMutation")
253            }
254
255            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AddMutation, V::Error>
256                where
257                    V: serde::de::MapAccess<'de>,
258            {
259                let mut actor_dispatchers__ = None;
260                let mut added_actors__ = None;
261                let mut actor_splits__ = None;
262                let mut pause__ = None;
263                let mut subscriptions_to_add__ = None;
264                let mut backfill_nodes_to_pause__ = None;
265                let mut actor_cdc_table_snapshot_splits__ = None;
266                let mut new_upstream_sinks__ = None;
267                while let Some(k) = map_.next_key()? {
268                    match k {
269                        GeneratedField::ActorDispatchers => {
270                            if actor_dispatchers__.is_some() {
271                                return Err(serde::de::Error::duplicate_field("actorDispatchers"));
272                            }
273                            actor_dispatchers__ = Some(
274                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
275                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
276                            );
277                        }
278                        GeneratedField::AddedActors => {
279                            if added_actors__.is_some() {
280                                return Err(serde::de::Error::duplicate_field("addedActors"));
281                            }
282                            added_actors__ = 
283                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
284                                    .into_iter().map(|x| x.0).collect())
285                            ;
286                        }
287                        GeneratedField::ActorSplits => {
288                            if actor_splits__.is_some() {
289                                return Err(serde::de::Error::duplicate_field("actorSplits"));
290                            }
291                            actor_splits__ = Some(
292                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
293                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
294                            );
295                        }
296                        GeneratedField::Pause => {
297                            if pause__.is_some() {
298                                return Err(serde::de::Error::duplicate_field("pause"));
299                            }
300                            pause__ = Some(map_.next_value()?);
301                        }
302                        GeneratedField::SubscriptionsToAdd => {
303                            if subscriptions_to_add__.is_some() {
304                                return Err(serde::de::Error::duplicate_field("subscriptionsToAdd"));
305                            }
306                            subscriptions_to_add__ = Some(map_.next_value()?);
307                        }
308                        GeneratedField::BackfillNodesToPause => {
309                            if backfill_nodes_to_pause__.is_some() {
310                                return Err(serde::de::Error::duplicate_field("backfillNodesToPause"));
311                            }
312                            backfill_nodes_to_pause__ = 
313                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
314                                    .into_iter().map(|x| x.0).collect())
315                            ;
316                        }
317                        GeneratedField::ActorCdcTableSnapshotSplits => {
318                            if actor_cdc_table_snapshot_splits__.is_some() {
319                                return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
320                            }
321                            actor_cdc_table_snapshot_splits__ = map_.next_value()?;
322                        }
323                        GeneratedField::NewUpstreamSinks => {
324                            if new_upstream_sinks__.is_some() {
325                                return Err(serde::de::Error::duplicate_field("newUpstreamSinks"));
326                            }
327                            new_upstream_sinks__ = Some(
328                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
329                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
330                            );
331                        }
332                    }
333                }
334                Ok(AddMutation {
335                    actor_dispatchers: actor_dispatchers__.unwrap_or_default(),
336                    added_actors: added_actors__.unwrap_or_default(),
337                    actor_splits: actor_splits__.unwrap_or_default(),
338                    pause: pause__.unwrap_or_default(),
339                    subscriptions_to_add: subscriptions_to_add__.unwrap_or_default(),
340                    backfill_nodes_to_pause: backfill_nodes_to_pause__.unwrap_or_default(),
341                    actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
342                    new_upstream_sinks: new_upstream_sinks__.unwrap_or_default(),
343                })
344            }
345        }
346        deserializer.deserialize_struct("stream_plan.AddMutation", FIELDS, GeneratedVisitor)
347    }
348}
349impl serde::Serialize for add_mutation::NewUpstreamSink {
350    #[allow(deprecated)]
351    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
352    where
353        S: serde::Serializer,
354    {
355        use serde::ser::SerializeStruct;
356        let mut len = 0;
357        if self.info.is_some() {
358            len += 1;
359        }
360        if !self.upstream_actors.is_empty() {
361            len += 1;
362        }
363        let mut struct_ser = serializer.serialize_struct("stream_plan.AddMutation.NewUpstreamSink", len)?;
364        if let Some(v) = self.info.as_ref() {
365            struct_ser.serialize_field("info", v)?;
366        }
367        if !self.upstream_actors.is_empty() {
368            struct_ser.serialize_field("upstreamActors", &self.upstream_actors)?;
369        }
370        struct_ser.end()
371    }
372}
373impl<'de> serde::Deserialize<'de> for add_mutation::NewUpstreamSink {
374    #[allow(deprecated)]
375    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
376    where
377        D: serde::Deserializer<'de>,
378    {
379        const FIELDS: &[&str] = &[
380            "info",
381            "upstream_actors",
382            "upstreamActors",
383        ];
384
385        #[allow(clippy::enum_variant_names)]
386        enum GeneratedField {
387            Info,
388            UpstreamActors,
389        }
390        impl<'de> serde::Deserialize<'de> for GeneratedField {
391            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
392            where
393                D: serde::Deserializer<'de>,
394            {
395                struct GeneratedVisitor;
396
397                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
398                    type Value = GeneratedField;
399
400                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
401                        write!(formatter, "expected one of: {:?}", &FIELDS)
402                    }
403
404                    #[allow(unused_variables)]
405                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
406                    where
407                        E: serde::de::Error,
408                    {
409                        match value {
410                            "info" => Ok(GeneratedField::Info),
411                            "upstreamActors" | "upstream_actors" => Ok(GeneratedField::UpstreamActors),
412                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
413                        }
414                    }
415                }
416                deserializer.deserialize_identifier(GeneratedVisitor)
417            }
418        }
419        struct GeneratedVisitor;
420        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
421            type Value = add_mutation::NewUpstreamSink;
422
423            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
424                formatter.write_str("struct stream_plan.AddMutation.NewUpstreamSink")
425            }
426
427            fn visit_map<V>(self, mut map_: V) -> std::result::Result<add_mutation::NewUpstreamSink, V::Error>
428                where
429                    V: serde::de::MapAccess<'de>,
430            {
431                let mut info__ = None;
432                let mut upstream_actors__ = None;
433                while let Some(k) = map_.next_key()? {
434                    match k {
435                        GeneratedField::Info => {
436                            if info__.is_some() {
437                                return Err(serde::de::Error::duplicate_field("info"));
438                            }
439                            info__ = map_.next_value()?;
440                        }
441                        GeneratedField::UpstreamActors => {
442                            if upstream_actors__.is_some() {
443                                return Err(serde::de::Error::duplicate_field("upstreamActors"));
444                            }
445                            upstream_actors__ = Some(map_.next_value()?);
446                        }
447                    }
448                }
449                Ok(add_mutation::NewUpstreamSink {
450                    info: info__,
451                    upstream_actors: upstream_actors__.unwrap_or_default(),
452                })
453            }
454        }
455        deserializer.deserialize_struct("stream_plan.AddMutation.NewUpstreamSink", FIELDS, GeneratedVisitor)
456    }
457}
458impl serde::Serialize for AggCallState {
459    #[allow(deprecated)]
460    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
461    where
462        S: serde::Serializer,
463    {
464        use serde::ser::SerializeStruct;
465        let mut len = 0;
466        if self.inner.is_some() {
467            len += 1;
468        }
469        let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState", len)?;
470        if let Some(v) = self.inner.as_ref() {
471            match v {
472                agg_call_state::Inner::ValueState(v) => {
473                    struct_ser.serialize_field("valueState", v)?;
474                }
475                agg_call_state::Inner::MaterializedInputState(v) => {
476                    struct_ser.serialize_field("materializedInputState", v)?;
477                }
478            }
479        }
480        struct_ser.end()
481    }
482}
483impl<'de> serde::Deserialize<'de> for AggCallState {
484    #[allow(deprecated)]
485    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
486    where
487        D: serde::Deserializer<'de>,
488    {
489        const FIELDS: &[&str] = &[
490            "value_state",
491            "valueState",
492            "materialized_input_state",
493            "materializedInputState",
494        ];
495
496        #[allow(clippy::enum_variant_names)]
497        enum GeneratedField {
498            ValueState,
499            MaterializedInputState,
500        }
501        impl<'de> serde::Deserialize<'de> for GeneratedField {
502            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
503            where
504                D: serde::Deserializer<'de>,
505            {
506                struct GeneratedVisitor;
507
508                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
509                    type Value = GeneratedField;
510
511                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
512                        write!(formatter, "expected one of: {:?}", &FIELDS)
513                    }
514
515                    #[allow(unused_variables)]
516                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
517                    where
518                        E: serde::de::Error,
519                    {
520                        match value {
521                            "valueState" | "value_state" => Ok(GeneratedField::ValueState),
522                            "materializedInputState" | "materialized_input_state" => Ok(GeneratedField::MaterializedInputState),
523                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
524                        }
525                    }
526                }
527                deserializer.deserialize_identifier(GeneratedVisitor)
528            }
529        }
530        struct GeneratedVisitor;
531        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
532            type Value = AggCallState;
533
534            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
535                formatter.write_str("struct stream_plan.AggCallState")
536            }
537
538            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AggCallState, V::Error>
539                where
540                    V: serde::de::MapAccess<'de>,
541            {
542                let mut inner__ = None;
543                while let Some(k) = map_.next_key()? {
544                    match k {
545                        GeneratedField::ValueState => {
546                            if inner__.is_some() {
547                                return Err(serde::de::Error::duplicate_field("valueState"));
548                            }
549                            inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::ValueState)
550;
551                        }
552                        GeneratedField::MaterializedInputState => {
553                            if inner__.is_some() {
554                                return Err(serde::de::Error::duplicate_field("materializedInputState"));
555                            }
556                            inner__ = map_.next_value::<::std::option::Option<_>>()?.map(agg_call_state::Inner::MaterializedInputState)
557;
558                        }
559                    }
560                }
561                Ok(AggCallState {
562                    inner: inner__,
563                })
564            }
565        }
566        deserializer.deserialize_struct("stream_plan.AggCallState", FIELDS, GeneratedVisitor)
567    }
568}
569impl serde::Serialize for agg_call_state::MaterializedInputState {
570    #[allow(deprecated)]
571    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
572    where
573        S: serde::Serializer,
574    {
575        use serde::ser::SerializeStruct;
576        let mut len = 0;
577        if self.table.is_some() {
578            len += 1;
579        }
580        if !self.included_upstream_indices.is_empty() {
581            len += 1;
582        }
583        if !self.table_value_indices.is_empty() {
584            len += 1;
585        }
586        if !self.order_columns.is_empty() {
587            len += 1;
588        }
589        let mut struct_ser = serializer.serialize_struct("stream_plan.AggCallState.MaterializedInputState", len)?;
590        if let Some(v) = self.table.as_ref() {
591            struct_ser.serialize_field("table", v)?;
592        }
593        if !self.included_upstream_indices.is_empty() {
594            struct_ser.serialize_field("includedUpstreamIndices", &self.included_upstream_indices)?;
595        }
596        if !self.table_value_indices.is_empty() {
597            struct_ser.serialize_field("tableValueIndices", &self.table_value_indices)?;
598        }
599        if !self.order_columns.is_empty() {
600            struct_ser.serialize_field("orderColumns", &self.order_columns)?;
601        }
602        struct_ser.end()
603    }
604}
605impl<'de> serde::Deserialize<'de> for agg_call_state::MaterializedInputState {
606    #[allow(deprecated)]
607    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
608    where
609        D: serde::Deserializer<'de>,
610    {
611        const FIELDS: &[&str] = &[
612            "table",
613            "included_upstream_indices",
614            "includedUpstreamIndices",
615            "table_value_indices",
616            "tableValueIndices",
617            "order_columns",
618            "orderColumns",
619        ];
620
621        #[allow(clippy::enum_variant_names)]
622        enum GeneratedField {
623            Table,
624            IncludedUpstreamIndices,
625            TableValueIndices,
626            OrderColumns,
627        }
628        impl<'de> serde::Deserialize<'de> for GeneratedField {
629            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
630            where
631                D: serde::Deserializer<'de>,
632            {
633                struct GeneratedVisitor;
634
635                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
636                    type Value = GeneratedField;
637
638                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
639                        write!(formatter, "expected one of: {:?}", &FIELDS)
640                    }
641
642                    #[allow(unused_variables)]
643                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
644                    where
645                        E: serde::de::Error,
646                    {
647                        match value {
648                            "table" => Ok(GeneratedField::Table),
649                            "includedUpstreamIndices" | "included_upstream_indices" => Ok(GeneratedField::IncludedUpstreamIndices),
650                            "tableValueIndices" | "table_value_indices" => Ok(GeneratedField::TableValueIndices),
651                            "orderColumns" | "order_columns" => Ok(GeneratedField::OrderColumns),
652                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
653                        }
654                    }
655                }
656                deserializer.deserialize_identifier(GeneratedVisitor)
657            }
658        }
659        struct GeneratedVisitor;
660        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
661            type Value = agg_call_state::MaterializedInputState;
662
663            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
664                formatter.write_str("struct stream_plan.AggCallState.MaterializedInputState")
665            }
666
667            fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::MaterializedInputState, V::Error>
668                where
669                    V: serde::de::MapAccess<'de>,
670            {
671                let mut table__ = None;
672                let mut included_upstream_indices__ = None;
673                let mut table_value_indices__ = None;
674                let mut order_columns__ = None;
675                while let Some(k) = map_.next_key()? {
676                    match k {
677                        GeneratedField::Table => {
678                            if table__.is_some() {
679                                return Err(serde::de::Error::duplicate_field("table"));
680                            }
681                            table__ = map_.next_value()?;
682                        }
683                        GeneratedField::IncludedUpstreamIndices => {
684                            if included_upstream_indices__.is_some() {
685                                return Err(serde::de::Error::duplicate_field("includedUpstreamIndices"));
686                            }
687                            included_upstream_indices__ = 
688                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
689                                    .into_iter().map(|x| x.0).collect())
690                            ;
691                        }
692                        GeneratedField::TableValueIndices => {
693                            if table_value_indices__.is_some() {
694                                return Err(serde::de::Error::duplicate_field("tableValueIndices"));
695                            }
696                            table_value_indices__ = 
697                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
698                                    .into_iter().map(|x| x.0).collect())
699                            ;
700                        }
701                        GeneratedField::OrderColumns => {
702                            if order_columns__.is_some() {
703                                return Err(serde::de::Error::duplicate_field("orderColumns"));
704                            }
705                            order_columns__ = Some(map_.next_value()?);
706                        }
707                    }
708                }
709                Ok(agg_call_state::MaterializedInputState {
710                    table: table__,
711                    included_upstream_indices: included_upstream_indices__.unwrap_or_default(),
712                    table_value_indices: table_value_indices__.unwrap_or_default(),
713                    order_columns: order_columns__.unwrap_or_default(),
714                })
715            }
716        }
717        deserializer.deserialize_struct("stream_plan.AggCallState.MaterializedInputState", FIELDS, GeneratedVisitor)
718    }
719}
720impl serde::Serialize for agg_call_state::ValueState {
721    #[allow(deprecated)]
722    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
723    where
724        S: serde::Serializer,
725    {
726        use serde::ser::SerializeStruct;
727        let len = 0;
728        let struct_ser = serializer.serialize_struct("stream_plan.AggCallState.ValueState", len)?;
729        struct_ser.end()
730    }
731}
732impl<'de> serde::Deserialize<'de> for agg_call_state::ValueState {
733    #[allow(deprecated)]
734    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
735    where
736        D: serde::Deserializer<'de>,
737    {
738        const FIELDS: &[&str] = &[
739        ];
740
741        #[allow(clippy::enum_variant_names)]
742        enum GeneratedField {
743        }
744        impl<'de> serde::Deserialize<'de> for GeneratedField {
745            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
746            where
747                D: serde::Deserializer<'de>,
748            {
749                struct GeneratedVisitor;
750
751                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
752                    type Value = GeneratedField;
753
754                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
755                        write!(formatter, "expected one of: {:?}", &FIELDS)
756                    }
757
758                    #[allow(unused_variables)]
759                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
760                    where
761                        E: serde::de::Error,
762                    {
763                            Err(serde::de::Error::unknown_field(value, FIELDS))
764                    }
765                }
766                deserializer.deserialize_identifier(GeneratedVisitor)
767            }
768        }
769        struct GeneratedVisitor;
770        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
771            type Value = agg_call_state::ValueState;
772
773            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
774                formatter.write_str("struct stream_plan.AggCallState.ValueState")
775            }
776
777            fn visit_map<V>(self, mut map_: V) -> std::result::Result<agg_call_state::ValueState, V::Error>
778                where
779                    V: serde::de::MapAccess<'de>,
780            {
781                while map_.next_key::<GeneratedField>()?.is_some() {
782                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
783                }
784                Ok(agg_call_state::ValueState {
785                })
786            }
787        }
788        deserializer.deserialize_struct("stream_plan.AggCallState.ValueState", FIELDS, GeneratedVisitor)
789    }
790}
791impl serde::Serialize for AggNodeVersion {
792    #[allow(deprecated)]
793    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
794    where
795        S: serde::Serializer,
796    {
797        let variant = match self {
798            Self::Unspecified => "AGG_NODE_VERSION_UNSPECIFIED",
799            Self::Issue12140 => "AGG_NODE_VERSION_ISSUE_12140",
800            Self::Issue13465 => "AGG_NODE_VERSION_ISSUE_13465",
801        };
802        serializer.serialize_str(variant)
803    }
804}
805impl<'de> serde::Deserialize<'de> for AggNodeVersion {
806    #[allow(deprecated)]
807    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
808    where
809        D: serde::Deserializer<'de>,
810    {
811        const FIELDS: &[&str] = &[
812            "AGG_NODE_VERSION_UNSPECIFIED",
813            "AGG_NODE_VERSION_ISSUE_12140",
814            "AGG_NODE_VERSION_ISSUE_13465",
815        ];
816
817        struct GeneratedVisitor;
818
819        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
820            type Value = AggNodeVersion;
821
822            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
823                write!(formatter, "expected one of: {:?}", &FIELDS)
824            }
825
826            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
827            where
828                E: serde::de::Error,
829            {
830                i32::try_from(v)
831                    .ok()
832                    .and_then(|x| x.try_into().ok())
833                    .ok_or_else(|| {
834                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
835                    })
836            }
837
838            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
839            where
840                E: serde::de::Error,
841            {
842                i32::try_from(v)
843                    .ok()
844                    .and_then(|x| x.try_into().ok())
845                    .ok_or_else(|| {
846                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
847                    })
848            }
849
850            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
851            where
852                E: serde::de::Error,
853            {
854                match value {
855                    "AGG_NODE_VERSION_UNSPECIFIED" => Ok(AggNodeVersion::Unspecified),
856                    "AGG_NODE_VERSION_ISSUE_12140" => Ok(AggNodeVersion::Issue12140),
857                    "AGG_NODE_VERSION_ISSUE_13465" => Ok(AggNodeVersion::Issue13465),
858                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
859                }
860            }
861        }
862        deserializer.deserialize_any(GeneratedVisitor)
863    }
864}
865impl serde::Serialize for ArrangeNode {
866    #[allow(deprecated)]
867    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
868    where
869        S: serde::Serializer,
870    {
871        use serde::ser::SerializeStruct;
872        let mut len = 0;
873        if self.table_info.is_some() {
874            len += 1;
875        }
876        if !self.distribution_key.is_empty() {
877            len += 1;
878        }
879        if self.table.is_some() {
880            len += 1;
881        }
882        let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangeNode", len)?;
883        if let Some(v) = self.table_info.as_ref() {
884            struct_ser.serialize_field("tableInfo", v)?;
885        }
886        if !self.distribution_key.is_empty() {
887            struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
888        }
889        if let Some(v) = self.table.as_ref() {
890            struct_ser.serialize_field("table", v)?;
891        }
892        struct_ser.end()
893    }
894}
895impl<'de> serde::Deserialize<'de> for ArrangeNode {
896    #[allow(deprecated)]
897    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
898    where
899        D: serde::Deserializer<'de>,
900    {
901        const FIELDS: &[&str] = &[
902            "table_info",
903            "tableInfo",
904            "distribution_key",
905            "distributionKey",
906            "table",
907        ];
908
909        #[allow(clippy::enum_variant_names)]
910        enum GeneratedField {
911            TableInfo,
912            DistributionKey,
913            Table,
914        }
915        impl<'de> serde::Deserialize<'de> for GeneratedField {
916            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
917            where
918                D: serde::Deserializer<'de>,
919            {
920                struct GeneratedVisitor;
921
922                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
923                    type Value = GeneratedField;
924
925                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
926                        write!(formatter, "expected one of: {:?}", &FIELDS)
927                    }
928
929                    #[allow(unused_variables)]
930                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
931                    where
932                        E: serde::de::Error,
933                    {
934                        match value {
935                            "tableInfo" | "table_info" => Ok(GeneratedField::TableInfo),
936                            "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
937                            "table" => Ok(GeneratedField::Table),
938                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
939                        }
940                    }
941                }
942                deserializer.deserialize_identifier(GeneratedVisitor)
943            }
944        }
945        struct GeneratedVisitor;
946        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
947            type Value = ArrangeNode;
948
949            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
950                formatter.write_str("struct stream_plan.ArrangeNode")
951            }
952
953            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangeNode, V::Error>
954                where
955                    V: serde::de::MapAccess<'de>,
956            {
957                let mut table_info__ = None;
958                let mut distribution_key__ = None;
959                let mut table__ = None;
960                while let Some(k) = map_.next_key()? {
961                    match k {
962                        GeneratedField::TableInfo => {
963                            if table_info__.is_some() {
964                                return Err(serde::de::Error::duplicate_field("tableInfo"));
965                            }
966                            table_info__ = map_.next_value()?;
967                        }
968                        GeneratedField::DistributionKey => {
969                            if distribution_key__.is_some() {
970                                return Err(serde::de::Error::duplicate_field("distributionKey"));
971                            }
972                            distribution_key__ = 
973                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
974                                    .into_iter().map(|x| x.0).collect())
975                            ;
976                        }
977                        GeneratedField::Table => {
978                            if table__.is_some() {
979                                return Err(serde::de::Error::duplicate_field("table"));
980                            }
981                            table__ = map_.next_value()?;
982                        }
983                    }
984                }
985                Ok(ArrangeNode {
986                    table_info: table_info__,
987                    distribution_key: distribution_key__.unwrap_or_default(),
988                    table: table__,
989                })
990            }
991        }
992        deserializer.deserialize_struct("stream_plan.ArrangeNode", FIELDS, GeneratedVisitor)
993    }
994}
995impl serde::Serialize for ArrangementInfo {
996    #[allow(deprecated)]
997    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
998    where
999        S: serde::Serializer,
1000    {
1001        use serde::ser::SerializeStruct;
1002        let mut len = 0;
1003        if !self.arrange_key_orders.is_empty() {
1004            len += 1;
1005        }
1006        if !self.column_descs.is_empty() {
1007            len += 1;
1008        }
1009        if self.table_desc.is_some() {
1010            len += 1;
1011        }
1012        if !self.output_col_idx.is_empty() {
1013            len += 1;
1014        }
1015        let mut struct_ser = serializer.serialize_struct("stream_plan.ArrangementInfo", len)?;
1016        if !self.arrange_key_orders.is_empty() {
1017            struct_ser.serialize_field("arrangeKeyOrders", &self.arrange_key_orders)?;
1018        }
1019        if !self.column_descs.is_empty() {
1020            struct_ser.serialize_field("columnDescs", &self.column_descs)?;
1021        }
1022        if let Some(v) = self.table_desc.as_ref() {
1023            struct_ser.serialize_field("tableDesc", v)?;
1024        }
1025        if !self.output_col_idx.is_empty() {
1026            struct_ser.serialize_field("outputColIdx", &self.output_col_idx)?;
1027        }
1028        struct_ser.end()
1029    }
1030}
1031impl<'de> serde::Deserialize<'de> for ArrangementInfo {
1032    #[allow(deprecated)]
1033    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1034    where
1035        D: serde::Deserializer<'de>,
1036    {
1037        const FIELDS: &[&str] = &[
1038            "arrange_key_orders",
1039            "arrangeKeyOrders",
1040            "column_descs",
1041            "columnDescs",
1042            "table_desc",
1043            "tableDesc",
1044            "output_col_idx",
1045            "outputColIdx",
1046        ];
1047
1048        #[allow(clippy::enum_variant_names)]
1049        enum GeneratedField {
1050            ArrangeKeyOrders,
1051            ColumnDescs,
1052            TableDesc,
1053            OutputColIdx,
1054        }
1055        impl<'de> serde::Deserialize<'de> for GeneratedField {
1056            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1057            where
1058                D: serde::Deserializer<'de>,
1059            {
1060                struct GeneratedVisitor;
1061
1062                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1063                    type Value = GeneratedField;
1064
1065                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1066                        write!(formatter, "expected one of: {:?}", &FIELDS)
1067                    }
1068
1069                    #[allow(unused_variables)]
1070                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1071                    where
1072                        E: serde::de::Error,
1073                    {
1074                        match value {
1075                            "arrangeKeyOrders" | "arrange_key_orders" => Ok(GeneratedField::ArrangeKeyOrders),
1076                            "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
1077                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
1078                            "outputColIdx" | "output_col_idx" => Ok(GeneratedField::OutputColIdx),
1079                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1080                        }
1081                    }
1082                }
1083                deserializer.deserialize_identifier(GeneratedVisitor)
1084            }
1085        }
1086        struct GeneratedVisitor;
1087        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1088            type Value = ArrangementInfo;
1089
1090            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1091                formatter.write_str("struct stream_plan.ArrangementInfo")
1092            }
1093
1094            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ArrangementInfo, V::Error>
1095                where
1096                    V: serde::de::MapAccess<'de>,
1097            {
1098                let mut arrange_key_orders__ = None;
1099                let mut column_descs__ = None;
1100                let mut table_desc__ = None;
1101                let mut output_col_idx__ = None;
1102                while let Some(k) = map_.next_key()? {
1103                    match k {
1104                        GeneratedField::ArrangeKeyOrders => {
1105                            if arrange_key_orders__.is_some() {
1106                                return Err(serde::de::Error::duplicate_field("arrangeKeyOrders"));
1107                            }
1108                            arrange_key_orders__ = Some(map_.next_value()?);
1109                        }
1110                        GeneratedField::ColumnDescs => {
1111                            if column_descs__.is_some() {
1112                                return Err(serde::de::Error::duplicate_field("columnDescs"));
1113                            }
1114                            column_descs__ = Some(map_.next_value()?);
1115                        }
1116                        GeneratedField::TableDesc => {
1117                            if table_desc__.is_some() {
1118                                return Err(serde::de::Error::duplicate_field("tableDesc"));
1119                            }
1120                            table_desc__ = map_.next_value()?;
1121                        }
1122                        GeneratedField::OutputColIdx => {
1123                            if output_col_idx__.is_some() {
1124                                return Err(serde::de::Error::duplicate_field("outputColIdx"));
1125                            }
1126                            output_col_idx__ = 
1127                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1128                                    .into_iter().map(|x| x.0).collect())
1129                            ;
1130                        }
1131                    }
1132                }
1133                Ok(ArrangementInfo {
1134                    arrange_key_orders: arrange_key_orders__.unwrap_or_default(),
1135                    column_descs: column_descs__.unwrap_or_default(),
1136                    table_desc: table_desc__,
1137                    output_col_idx: output_col_idx__.unwrap_or_default(),
1138                })
1139            }
1140        }
1141        deserializer.deserialize_struct("stream_plan.ArrangementInfo", FIELDS, GeneratedVisitor)
1142    }
1143}
1144impl serde::Serialize for AsOfJoinNode {
1145    #[allow(deprecated)]
1146    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1147    where
1148        S: serde::Serializer,
1149    {
1150        use serde::ser::SerializeStruct;
1151        let mut len = 0;
1152        if self.join_type != 0 {
1153            len += 1;
1154        }
1155        if !self.left_key.is_empty() {
1156            len += 1;
1157        }
1158        if !self.right_key.is_empty() {
1159            len += 1;
1160        }
1161        if self.left_table.is_some() {
1162            len += 1;
1163        }
1164        if self.right_table.is_some() {
1165            len += 1;
1166        }
1167        if !self.output_indices.is_empty() {
1168            len += 1;
1169        }
1170        if !self.left_deduped_input_pk_indices.is_empty() {
1171            len += 1;
1172        }
1173        if !self.right_deduped_input_pk_indices.is_empty() {
1174            len += 1;
1175        }
1176        if !self.null_safe.is_empty() {
1177            len += 1;
1178        }
1179        if self.asof_desc.is_some() {
1180            len += 1;
1181        }
1182        if self.join_encoding_type != 0 {
1183            len += 1;
1184        }
1185        let mut struct_ser = serializer.serialize_struct("stream_plan.AsOfJoinNode", len)?;
1186        if self.join_type != 0 {
1187            let v = super::plan_common::AsOfJoinType::try_from(self.join_type)
1188                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
1189            struct_ser.serialize_field("joinType", &v)?;
1190        }
1191        if !self.left_key.is_empty() {
1192            struct_ser.serialize_field("leftKey", &self.left_key)?;
1193        }
1194        if !self.right_key.is_empty() {
1195            struct_ser.serialize_field("rightKey", &self.right_key)?;
1196        }
1197        if let Some(v) = self.left_table.as_ref() {
1198            struct_ser.serialize_field("leftTable", v)?;
1199        }
1200        if let Some(v) = self.right_table.as_ref() {
1201            struct_ser.serialize_field("rightTable", v)?;
1202        }
1203        if !self.output_indices.is_empty() {
1204            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
1205        }
1206        if !self.left_deduped_input_pk_indices.is_empty() {
1207            struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
1208        }
1209        if !self.right_deduped_input_pk_indices.is_empty() {
1210            struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
1211        }
1212        if !self.null_safe.is_empty() {
1213            struct_ser.serialize_field("nullSafe", &self.null_safe)?;
1214        }
1215        if let Some(v) = self.asof_desc.as_ref() {
1216            struct_ser.serialize_field("asofDesc", v)?;
1217        }
1218        if self.join_encoding_type != 0 {
1219            let v = JoinEncodingType::try_from(self.join_encoding_type)
1220                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
1221            struct_ser.serialize_field("joinEncodingType", &v)?;
1222        }
1223        struct_ser.end()
1224    }
1225}
1226impl<'de> serde::Deserialize<'de> for AsOfJoinNode {
1227    #[allow(deprecated)]
1228    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1229    where
1230        D: serde::Deserializer<'de>,
1231    {
1232        const FIELDS: &[&str] = &[
1233            "join_type",
1234            "joinType",
1235            "left_key",
1236            "leftKey",
1237            "right_key",
1238            "rightKey",
1239            "left_table",
1240            "leftTable",
1241            "right_table",
1242            "rightTable",
1243            "output_indices",
1244            "outputIndices",
1245            "left_deduped_input_pk_indices",
1246            "leftDedupedInputPkIndices",
1247            "right_deduped_input_pk_indices",
1248            "rightDedupedInputPkIndices",
1249            "null_safe",
1250            "nullSafe",
1251            "asof_desc",
1252            "asofDesc",
1253            "join_encoding_type",
1254            "joinEncodingType",
1255        ];
1256
1257        #[allow(clippy::enum_variant_names)]
1258        enum GeneratedField {
1259            JoinType,
1260            LeftKey,
1261            RightKey,
1262            LeftTable,
1263            RightTable,
1264            OutputIndices,
1265            LeftDedupedInputPkIndices,
1266            RightDedupedInputPkIndices,
1267            NullSafe,
1268            AsofDesc,
1269            JoinEncodingType,
1270        }
1271        impl<'de> serde::Deserialize<'de> for GeneratedField {
1272            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1273            where
1274                D: serde::Deserializer<'de>,
1275            {
1276                struct GeneratedVisitor;
1277
1278                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1279                    type Value = GeneratedField;
1280
1281                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1282                        write!(formatter, "expected one of: {:?}", &FIELDS)
1283                    }
1284
1285                    #[allow(unused_variables)]
1286                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1287                    where
1288                        E: serde::de::Error,
1289                    {
1290                        match value {
1291                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
1292                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
1293                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
1294                            "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
1295                            "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
1296                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
1297                            "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
1298                            "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
1299                            "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
1300                            "asofDesc" | "asof_desc" => Ok(GeneratedField::AsofDesc),
1301                            "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
1302                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1303                        }
1304                    }
1305                }
1306                deserializer.deserialize_identifier(GeneratedVisitor)
1307            }
1308        }
1309        struct GeneratedVisitor;
1310        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1311            type Value = AsOfJoinNode;
1312
1313            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1314                formatter.write_str("struct stream_plan.AsOfJoinNode")
1315            }
1316
1317            fn visit_map<V>(self, mut map_: V) -> std::result::Result<AsOfJoinNode, V::Error>
1318                where
1319                    V: serde::de::MapAccess<'de>,
1320            {
1321                let mut join_type__ = None;
1322                let mut left_key__ = None;
1323                let mut right_key__ = None;
1324                let mut left_table__ = None;
1325                let mut right_table__ = None;
1326                let mut output_indices__ = None;
1327                let mut left_deduped_input_pk_indices__ = None;
1328                let mut right_deduped_input_pk_indices__ = None;
1329                let mut null_safe__ = None;
1330                let mut asof_desc__ = None;
1331                let mut join_encoding_type__ = None;
1332                while let Some(k) = map_.next_key()? {
1333                    match k {
1334                        GeneratedField::JoinType => {
1335                            if join_type__.is_some() {
1336                                return Err(serde::de::Error::duplicate_field("joinType"));
1337                            }
1338                            join_type__ = Some(map_.next_value::<super::plan_common::AsOfJoinType>()? as i32);
1339                        }
1340                        GeneratedField::LeftKey => {
1341                            if left_key__.is_some() {
1342                                return Err(serde::de::Error::duplicate_field("leftKey"));
1343                            }
1344                            left_key__ = 
1345                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1346                                    .into_iter().map(|x| x.0).collect())
1347                            ;
1348                        }
1349                        GeneratedField::RightKey => {
1350                            if right_key__.is_some() {
1351                                return Err(serde::de::Error::duplicate_field("rightKey"));
1352                            }
1353                            right_key__ = 
1354                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1355                                    .into_iter().map(|x| x.0).collect())
1356                            ;
1357                        }
1358                        GeneratedField::LeftTable => {
1359                            if left_table__.is_some() {
1360                                return Err(serde::de::Error::duplicate_field("leftTable"));
1361                            }
1362                            left_table__ = map_.next_value()?;
1363                        }
1364                        GeneratedField::RightTable => {
1365                            if right_table__.is_some() {
1366                                return Err(serde::de::Error::duplicate_field("rightTable"));
1367                            }
1368                            right_table__ = map_.next_value()?;
1369                        }
1370                        GeneratedField::OutputIndices => {
1371                            if output_indices__.is_some() {
1372                                return Err(serde::de::Error::duplicate_field("outputIndices"));
1373                            }
1374                            output_indices__ = 
1375                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1376                                    .into_iter().map(|x| x.0).collect())
1377                            ;
1378                        }
1379                        GeneratedField::LeftDedupedInputPkIndices => {
1380                            if left_deduped_input_pk_indices__.is_some() {
1381                                return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
1382                            }
1383                            left_deduped_input_pk_indices__ = 
1384                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1385                                    .into_iter().map(|x| x.0).collect())
1386                            ;
1387                        }
1388                        GeneratedField::RightDedupedInputPkIndices => {
1389                            if right_deduped_input_pk_indices__.is_some() {
1390                                return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
1391                            }
1392                            right_deduped_input_pk_indices__ = 
1393                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1394                                    .into_iter().map(|x| x.0).collect())
1395                            ;
1396                        }
1397                        GeneratedField::NullSafe => {
1398                            if null_safe__.is_some() {
1399                                return Err(serde::de::Error::duplicate_field("nullSafe"));
1400                            }
1401                            null_safe__ = Some(map_.next_value()?);
1402                        }
1403                        GeneratedField::AsofDesc => {
1404                            if asof_desc__.is_some() {
1405                                return Err(serde::de::Error::duplicate_field("asofDesc"));
1406                            }
1407                            asof_desc__ = map_.next_value()?;
1408                        }
1409                        GeneratedField::JoinEncodingType => {
1410                            if join_encoding_type__.is_some() {
1411                                return Err(serde::de::Error::duplicate_field("joinEncodingType"));
1412                            }
1413                            join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
1414                        }
1415                    }
1416                }
1417                Ok(AsOfJoinNode {
1418                    join_type: join_type__.unwrap_or_default(),
1419                    left_key: left_key__.unwrap_or_default(),
1420                    right_key: right_key__.unwrap_or_default(),
1421                    left_table: left_table__,
1422                    right_table: right_table__,
1423                    output_indices: output_indices__.unwrap_or_default(),
1424                    left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
1425                    right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
1426                    null_safe: null_safe__.unwrap_or_default(),
1427                    asof_desc: asof_desc__,
1428                    join_encoding_type: join_encoding_type__.unwrap_or_default(),
1429                })
1430            }
1431        }
1432        deserializer.deserialize_struct("stream_plan.AsOfJoinNode", FIELDS, GeneratedVisitor)
1433    }
1434}
1435impl serde::Serialize for BackfillOrder {
1436    #[allow(deprecated)]
1437    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1438    where
1439        S: serde::Serializer,
1440    {
1441        use serde::ser::SerializeStruct;
1442        let mut len = 0;
1443        if !self.order.is_empty() {
1444            len += 1;
1445        }
1446        let mut struct_ser = serializer.serialize_struct("stream_plan.BackfillOrder", len)?;
1447        if !self.order.is_empty() {
1448            struct_ser.serialize_field("order", &self.order)?;
1449        }
1450        struct_ser.end()
1451    }
1452}
1453impl<'de> serde::Deserialize<'de> for BackfillOrder {
1454    #[allow(deprecated)]
1455    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1456    where
1457        D: serde::Deserializer<'de>,
1458    {
1459        const FIELDS: &[&str] = &[
1460            "order",
1461        ];
1462
1463        #[allow(clippy::enum_variant_names)]
1464        enum GeneratedField {
1465            Order,
1466        }
1467        impl<'de> serde::Deserialize<'de> for GeneratedField {
1468            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1469            where
1470                D: serde::Deserializer<'de>,
1471            {
1472                struct GeneratedVisitor;
1473
1474                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1475                    type Value = GeneratedField;
1476
1477                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1478                        write!(formatter, "expected one of: {:?}", &FIELDS)
1479                    }
1480
1481                    #[allow(unused_variables)]
1482                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1483                    where
1484                        E: serde::de::Error,
1485                    {
1486                        match value {
1487                            "order" => Ok(GeneratedField::Order),
1488                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1489                        }
1490                    }
1491                }
1492                deserializer.deserialize_identifier(GeneratedVisitor)
1493            }
1494        }
1495        struct GeneratedVisitor;
1496        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1497            type Value = BackfillOrder;
1498
1499            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1500                formatter.write_str("struct stream_plan.BackfillOrder")
1501            }
1502
1503            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BackfillOrder, V::Error>
1504                where
1505                    V: serde::de::MapAccess<'de>,
1506            {
1507                let mut order__ = None;
1508                while let Some(k) = map_.next_key()? {
1509                    match k {
1510                        GeneratedField::Order => {
1511                            if order__.is_some() {
1512                                return Err(serde::de::Error::duplicate_field("order"));
1513                            }
1514                            order__ = Some(
1515                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
1516                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
1517                            );
1518                        }
1519                    }
1520                }
1521                Ok(BackfillOrder {
1522                    order: order__.unwrap_or_default(),
1523                })
1524            }
1525        }
1526        deserializer.deserialize_struct("stream_plan.BackfillOrder", FIELDS, GeneratedVisitor)
1527    }
1528}
1529impl serde::Serialize for Barrier {
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        use serde::ser::SerializeStruct;
1536        let mut len = 0;
1537        if self.epoch.is_some() {
1538            len += 1;
1539        }
1540        if self.mutation.is_some() {
1541            len += 1;
1542        }
1543        if !self.tracing_context.is_empty() {
1544            len += 1;
1545        }
1546        if self.kind != 0 {
1547            len += 1;
1548        }
1549        if !self.passed_actors.is_empty() {
1550            len += 1;
1551        }
1552        let mut struct_ser = serializer.serialize_struct("stream_plan.Barrier", len)?;
1553        if let Some(v) = self.epoch.as_ref() {
1554            struct_ser.serialize_field("epoch", v)?;
1555        }
1556        if let Some(v) = self.mutation.as_ref() {
1557            struct_ser.serialize_field("mutation", v)?;
1558        }
1559        if !self.tracing_context.is_empty() {
1560            struct_ser.serialize_field("tracingContext", &self.tracing_context)?;
1561        }
1562        if self.kind != 0 {
1563            let v = barrier::BarrierKind::try_from(self.kind)
1564                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.kind)))?;
1565            struct_ser.serialize_field("kind", &v)?;
1566        }
1567        if !self.passed_actors.is_empty() {
1568            struct_ser.serialize_field("passedActors", &self.passed_actors)?;
1569        }
1570        struct_ser.end()
1571    }
1572}
1573impl<'de> serde::Deserialize<'de> for Barrier {
1574    #[allow(deprecated)]
1575    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1576    where
1577        D: serde::Deserializer<'de>,
1578    {
1579        const FIELDS: &[&str] = &[
1580            "epoch",
1581            "mutation",
1582            "tracing_context",
1583            "tracingContext",
1584            "kind",
1585            "passed_actors",
1586            "passedActors",
1587        ];
1588
1589        #[allow(clippy::enum_variant_names)]
1590        enum GeneratedField {
1591            Epoch,
1592            Mutation,
1593            TracingContext,
1594            Kind,
1595            PassedActors,
1596        }
1597        impl<'de> serde::Deserialize<'de> for GeneratedField {
1598            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1599            where
1600                D: serde::Deserializer<'de>,
1601            {
1602                struct GeneratedVisitor;
1603
1604                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1605                    type Value = GeneratedField;
1606
1607                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1608                        write!(formatter, "expected one of: {:?}", &FIELDS)
1609                    }
1610
1611                    #[allow(unused_variables)]
1612                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1613                    where
1614                        E: serde::de::Error,
1615                    {
1616                        match value {
1617                            "epoch" => Ok(GeneratedField::Epoch),
1618                            "mutation" => Ok(GeneratedField::Mutation),
1619                            "tracingContext" | "tracing_context" => Ok(GeneratedField::TracingContext),
1620                            "kind" => Ok(GeneratedField::Kind),
1621                            "passedActors" | "passed_actors" => Ok(GeneratedField::PassedActors),
1622                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1623                        }
1624                    }
1625                }
1626                deserializer.deserialize_identifier(GeneratedVisitor)
1627            }
1628        }
1629        struct GeneratedVisitor;
1630        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1631            type Value = Barrier;
1632
1633            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1634                formatter.write_str("struct stream_plan.Barrier")
1635            }
1636
1637            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Barrier, V::Error>
1638                where
1639                    V: serde::de::MapAccess<'de>,
1640            {
1641                let mut epoch__ = None;
1642                let mut mutation__ = None;
1643                let mut tracing_context__ = None;
1644                let mut kind__ = None;
1645                let mut passed_actors__ = None;
1646                while let Some(k) = map_.next_key()? {
1647                    match k {
1648                        GeneratedField::Epoch => {
1649                            if epoch__.is_some() {
1650                                return Err(serde::de::Error::duplicate_field("epoch"));
1651                            }
1652                            epoch__ = map_.next_value()?;
1653                        }
1654                        GeneratedField::Mutation => {
1655                            if mutation__.is_some() {
1656                                return Err(serde::de::Error::duplicate_field("mutation"));
1657                            }
1658                            mutation__ = map_.next_value()?;
1659                        }
1660                        GeneratedField::TracingContext => {
1661                            if tracing_context__.is_some() {
1662                                return Err(serde::de::Error::duplicate_field("tracingContext"));
1663                            }
1664                            tracing_context__ = Some(
1665                                map_.next_value::<std::collections::HashMap<_, _>>()?
1666                            );
1667                        }
1668                        GeneratedField::Kind => {
1669                            if kind__.is_some() {
1670                                return Err(serde::de::Error::duplicate_field("kind"));
1671                            }
1672                            kind__ = Some(map_.next_value::<barrier::BarrierKind>()? as i32);
1673                        }
1674                        GeneratedField::PassedActors => {
1675                            if passed_actors__.is_some() {
1676                                return Err(serde::de::Error::duplicate_field("passedActors"));
1677                            }
1678                            passed_actors__ = 
1679                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
1680                                    .into_iter().map(|x| x.0).collect())
1681                            ;
1682                        }
1683                    }
1684                }
1685                Ok(Barrier {
1686                    epoch: epoch__,
1687                    mutation: mutation__,
1688                    tracing_context: tracing_context__.unwrap_or_default(),
1689                    kind: kind__.unwrap_or_default(),
1690                    passed_actors: passed_actors__.unwrap_or_default(),
1691                })
1692            }
1693        }
1694        deserializer.deserialize_struct("stream_plan.Barrier", FIELDS, GeneratedVisitor)
1695    }
1696}
1697impl serde::Serialize for barrier::BarrierKind {
1698    #[allow(deprecated)]
1699    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1700    where
1701        S: serde::Serializer,
1702    {
1703        let variant = match self {
1704            Self::Unspecified => "BARRIER_KIND_UNSPECIFIED",
1705            Self::Initial => "BARRIER_KIND_INITIAL",
1706            Self::Barrier => "BARRIER_KIND_BARRIER",
1707            Self::Checkpoint => "BARRIER_KIND_CHECKPOINT",
1708        };
1709        serializer.serialize_str(variant)
1710    }
1711}
1712impl<'de> serde::Deserialize<'de> for barrier::BarrierKind {
1713    #[allow(deprecated)]
1714    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1715    where
1716        D: serde::Deserializer<'de>,
1717    {
1718        const FIELDS: &[&str] = &[
1719            "BARRIER_KIND_UNSPECIFIED",
1720            "BARRIER_KIND_INITIAL",
1721            "BARRIER_KIND_BARRIER",
1722            "BARRIER_KIND_CHECKPOINT",
1723        ];
1724
1725        struct GeneratedVisitor;
1726
1727        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1728            type Value = barrier::BarrierKind;
1729
1730            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1731                write!(formatter, "expected one of: {:?}", &FIELDS)
1732            }
1733
1734            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
1735            where
1736                E: serde::de::Error,
1737            {
1738                i32::try_from(v)
1739                    .ok()
1740                    .and_then(|x| x.try_into().ok())
1741                    .ok_or_else(|| {
1742                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
1743                    })
1744            }
1745
1746            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
1747            where
1748                E: serde::de::Error,
1749            {
1750                i32::try_from(v)
1751                    .ok()
1752                    .and_then(|x| x.try_into().ok())
1753                    .ok_or_else(|| {
1754                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
1755                    })
1756            }
1757
1758            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
1759            where
1760                E: serde::de::Error,
1761            {
1762                match value {
1763                    "BARRIER_KIND_UNSPECIFIED" => Ok(barrier::BarrierKind::Unspecified),
1764                    "BARRIER_KIND_INITIAL" => Ok(barrier::BarrierKind::Initial),
1765                    "BARRIER_KIND_BARRIER" => Ok(barrier::BarrierKind::Barrier),
1766                    "BARRIER_KIND_CHECKPOINT" => Ok(barrier::BarrierKind::Checkpoint),
1767                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
1768                }
1769            }
1770        }
1771        deserializer.deserialize_any(GeneratedVisitor)
1772    }
1773}
1774impl serde::Serialize for BarrierMutation {
1775    #[allow(deprecated)]
1776    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
1777    where
1778        S: serde::Serializer,
1779    {
1780        use serde::ser::SerializeStruct;
1781        let mut len = 0;
1782        if self.mutation.is_some() {
1783            len += 1;
1784        }
1785        let mut struct_ser = serializer.serialize_struct("stream_plan.BarrierMutation", len)?;
1786        if let Some(v) = self.mutation.as_ref() {
1787            match v {
1788                barrier_mutation::Mutation::Add(v) => {
1789                    struct_ser.serialize_field("add", v)?;
1790                }
1791                barrier_mutation::Mutation::Stop(v) => {
1792                    struct_ser.serialize_field("stop", v)?;
1793                }
1794                barrier_mutation::Mutation::Update(v) => {
1795                    struct_ser.serialize_field("update", v)?;
1796                }
1797                barrier_mutation::Mutation::Splits(v) => {
1798                    struct_ser.serialize_field("splits", v)?;
1799                }
1800                barrier_mutation::Mutation::Pause(v) => {
1801                    struct_ser.serialize_field("pause", v)?;
1802                }
1803                barrier_mutation::Mutation::Resume(v) => {
1804                    struct_ser.serialize_field("resume", v)?;
1805                }
1806                barrier_mutation::Mutation::Throttle(v) => {
1807                    struct_ser.serialize_field("throttle", v)?;
1808                }
1809                barrier_mutation::Mutation::DropSubscriptions(v) => {
1810                    struct_ser.serialize_field("dropSubscriptions", v)?;
1811                }
1812                barrier_mutation::Mutation::ConnectorPropsChange(v) => {
1813                    struct_ser.serialize_field("connectorPropsChange", v)?;
1814                }
1815                barrier_mutation::Mutation::StartFragmentBackfill(v) => {
1816                    struct_ser.serialize_field("startFragmentBackfill", v)?;
1817                }
1818                barrier_mutation::Mutation::RefreshStart(v) => {
1819                    struct_ser.serialize_field("refreshStart", v)?;
1820                }
1821                barrier_mutation::Mutation::LoadFinish(v) => {
1822                    struct_ser.serialize_field("loadFinish", v)?;
1823                }
1824                barrier_mutation::Mutation::Combined(v) => {
1825                    struct_ser.serialize_field("combined", v)?;
1826                }
1827            }
1828        }
1829        struct_ser.end()
1830    }
1831}
1832impl<'de> serde::Deserialize<'de> for BarrierMutation {
1833    #[allow(deprecated)]
1834    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
1835    where
1836        D: serde::Deserializer<'de>,
1837    {
1838        const FIELDS: &[&str] = &[
1839            "add",
1840            "stop",
1841            "update",
1842            "splits",
1843            "pause",
1844            "resume",
1845            "throttle",
1846            "drop_subscriptions",
1847            "dropSubscriptions",
1848            "connector_props_change",
1849            "connectorPropsChange",
1850            "start_fragment_backfill",
1851            "startFragmentBackfill",
1852            "refresh_start",
1853            "refreshStart",
1854            "load_finish",
1855            "loadFinish",
1856            "combined",
1857        ];
1858
1859        #[allow(clippy::enum_variant_names)]
1860        enum GeneratedField {
1861            Add,
1862            Stop,
1863            Update,
1864            Splits,
1865            Pause,
1866            Resume,
1867            Throttle,
1868            DropSubscriptions,
1869            ConnectorPropsChange,
1870            StartFragmentBackfill,
1871            RefreshStart,
1872            LoadFinish,
1873            Combined,
1874        }
1875        impl<'de> serde::Deserialize<'de> for GeneratedField {
1876            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
1877            where
1878                D: serde::Deserializer<'de>,
1879            {
1880                struct GeneratedVisitor;
1881
1882                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1883                    type Value = GeneratedField;
1884
1885                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1886                        write!(formatter, "expected one of: {:?}", &FIELDS)
1887                    }
1888
1889                    #[allow(unused_variables)]
1890                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
1891                    where
1892                        E: serde::de::Error,
1893                    {
1894                        match value {
1895                            "add" => Ok(GeneratedField::Add),
1896                            "stop" => Ok(GeneratedField::Stop),
1897                            "update" => Ok(GeneratedField::Update),
1898                            "splits" => Ok(GeneratedField::Splits),
1899                            "pause" => Ok(GeneratedField::Pause),
1900                            "resume" => Ok(GeneratedField::Resume),
1901                            "throttle" => Ok(GeneratedField::Throttle),
1902                            "dropSubscriptions" | "drop_subscriptions" => Ok(GeneratedField::DropSubscriptions),
1903                            "connectorPropsChange" | "connector_props_change" => Ok(GeneratedField::ConnectorPropsChange),
1904                            "startFragmentBackfill" | "start_fragment_backfill" => Ok(GeneratedField::StartFragmentBackfill),
1905                            "refreshStart" | "refresh_start" => Ok(GeneratedField::RefreshStart),
1906                            "loadFinish" | "load_finish" => Ok(GeneratedField::LoadFinish),
1907                            "combined" => Ok(GeneratedField::Combined),
1908                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
1909                        }
1910                    }
1911                }
1912                deserializer.deserialize_identifier(GeneratedVisitor)
1913            }
1914        }
1915        struct GeneratedVisitor;
1916        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
1917            type Value = BarrierMutation;
1918
1919            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1920                formatter.write_str("struct stream_plan.BarrierMutation")
1921            }
1922
1923            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierMutation, V::Error>
1924                where
1925                    V: serde::de::MapAccess<'de>,
1926            {
1927                let mut mutation__ = None;
1928                while let Some(k) = map_.next_key()? {
1929                    match k {
1930                        GeneratedField::Add => {
1931                            if mutation__.is_some() {
1932                                return Err(serde::de::Error::duplicate_field("add"));
1933                            }
1934                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Add)
1935;
1936                        }
1937                        GeneratedField::Stop => {
1938                            if mutation__.is_some() {
1939                                return Err(serde::de::Error::duplicate_field("stop"));
1940                            }
1941                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Stop)
1942;
1943                        }
1944                        GeneratedField::Update => {
1945                            if mutation__.is_some() {
1946                                return Err(serde::de::Error::duplicate_field("update"));
1947                            }
1948                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Update)
1949;
1950                        }
1951                        GeneratedField::Splits => {
1952                            if mutation__.is_some() {
1953                                return Err(serde::de::Error::duplicate_field("splits"));
1954                            }
1955                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Splits)
1956;
1957                        }
1958                        GeneratedField::Pause => {
1959                            if mutation__.is_some() {
1960                                return Err(serde::de::Error::duplicate_field("pause"));
1961                            }
1962                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Pause)
1963;
1964                        }
1965                        GeneratedField::Resume => {
1966                            if mutation__.is_some() {
1967                                return Err(serde::de::Error::duplicate_field("resume"));
1968                            }
1969                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Resume)
1970;
1971                        }
1972                        GeneratedField::Throttle => {
1973                            if mutation__.is_some() {
1974                                return Err(serde::de::Error::duplicate_field("throttle"));
1975                            }
1976                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Throttle)
1977;
1978                        }
1979                        GeneratedField::DropSubscriptions => {
1980                            if mutation__.is_some() {
1981                                return Err(serde::de::Error::duplicate_field("dropSubscriptions"));
1982                            }
1983                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::DropSubscriptions)
1984;
1985                        }
1986                        GeneratedField::ConnectorPropsChange => {
1987                            if mutation__.is_some() {
1988                                return Err(serde::de::Error::duplicate_field("connectorPropsChange"));
1989                            }
1990                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::ConnectorPropsChange)
1991;
1992                        }
1993                        GeneratedField::StartFragmentBackfill => {
1994                            if mutation__.is_some() {
1995                                return Err(serde::de::Error::duplicate_field("startFragmentBackfill"));
1996                            }
1997                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::StartFragmentBackfill)
1998;
1999                        }
2000                        GeneratedField::RefreshStart => {
2001                            if mutation__.is_some() {
2002                                return Err(serde::de::Error::duplicate_field("refreshStart"));
2003                            }
2004                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::RefreshStart)
2005;
2006                        }
2007                        GeneratedField::LoadFinish => {
2008                            if mutation__.is_some() {
2009                                return Err(serde::de::Error::duplicate_field("loadFinish"));
2010                            }
2011                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::LoadFinish)
2012;
2013                        }
2014                        GeneratedField::Combined => {
2015                            if mutation__.is_some() {
2016                                return Err(serde::de::Error::duplicate_field("combined"));
2017                            }
2018                            mutation__ = map_.next_value::<::std::option::Option<_>>()?.map(barrier_mutation::Mutation::Combined)
2019;
2020                        }
2021                    }
2022                }
2023                Ok(BarrierMutation {
2024                    mutation: mutation__,
2025                })
2026            }
2027        }
2028        deserializer.deserialize_struct("stream_plan.BarrierMutation", FIELDS, GeneratedVisitor)
2029    }
2030}
2031impl serde::Serialize for BarrierRecvNode {
2032    #[allow(deprecated)]
2033    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2034    where
2035        S: serde::Serializer,
2036    {
2037        use serde::ser::SerializeStruct;
2038        let len = 0;
2039        let struct_ser = serializer.serialize_struct("stream_plan.BarrierRecvNode", len)?;
2040        struct_ser.end()
2041    }
2042}
2043impl<'de> serde::Deserialize<'de> for BarrierRecvNode {
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        ];
2051
2052        #[allow(clippy::enum_variant_names)]
2053        enum GeneratedField {
2054        }
2055        impl<'de> serde::Deserialize<'de> for GeneratedField {
2056            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2057            where
2058                D: serde::Deserializer<'de>,
2059            {
2060                struct GeneratedVisitor;
2061
2062                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2063                    type Value = GeneratedField;
2064
2065                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2066                        write!(formatter, "expected one of: {:?}", &FIELDS)
2067                    }
2068
2069                    #[allow(unused_variables)]
2070                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2071                    where
2072                        E: serde::de::Error,
2073                    {
2074                            Err(serde::de::Error::unknown_field(value, FIELDS))
2075                    }
2076                }
2077                deserializer.deserialize_identifier(GeneratedVisitor)
2078            }
2079        }
2080        struct GeneratedVisitor;
2081        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2082            type Value = BarrierRecvNode;
2083
2084            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2085                formatter.write_str("struct stream_plan.BarrierRecvNode")
2086            }
2087
2088            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BarrierRecvNode, V::Error>
2089                where
2090                    V: serde::de::MapAccess<'de>,
2091            {
2092                while map_.next_key::<GeneratedField>()?.is_some() {
2093                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
2094                }
2095                Ok(BarrierRecvNode {
2096                })
2097            }
2098        }
2099        deserializer.deserialize_struct("stream_plan.BarrierRecvNode", FIELDS, GeneratedVisitor)
2100    }
2101}
2102impl serde::Serialize for BatchPlanNode {
2103    #[allow(deprecated)]
2104    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2105    where
2106        S: serde::Serializer,
2107    {
2108        use serde::ser::SerializeStruct;
2109        let mut len = 0;
2110        if self.table_desc.is_some() {
2111            len += 1;
2112        }
2113        if !self.column_ids.is_empty() {
2114            len += 1;
2115        }
2116        let mut struct_ser = serializer.serialize_struct("stream_plan.BatchPlanNode", len)?;
2117        if let Some(v) = self.table_desc.as_ref() {
2118            struct_ser.serialize_field("tableDesc", v)?;
2119        }
2120        if !self.column_ids.is_empty() {
2121            struct_ser.serialize_field("columnIds", &self.column_ids)?;
2122        }
2123        struct_ser.end()
2124    }
2125}
2126impl<'de> serde::Deserialize<'de> for BatchPlanNode {
2127    #[allow(deprecated)]
2128    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2129    where
2130        D: serde::Deserializer<'de>,
2131    {
2132        const FIELDS: &[&str] = &[
2133            "table_desc",
2134            "tableDesc",
2135            "column_ids",
2136            "columnIds",
2137        ];
2138
2139        #[allow(clippy::enum_variant_names)]
2140        enum GeneratedField {
2141            TableDesc,
2142            ColumnIds,
2143        }
2144        impl<'de> serde::Deserialize<'de> for GeneratedField {
2145            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2146            where
2147                D: serde::Deserializer<'de>,
2148            {
2149                struct GeneratedVisitor;
2150
2151                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2152                    type Value = GeneratedField;
2153
2154                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2155                        write!(formatter, "expected one of: {:?}", &FIELDS)
2156                    }
2157
2158                    #[allow(unused_variables)]
2159                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2160                    where
2161                        E: serde::de::Error,
2162                    {
2163                        match value {
2164                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
2165                            "columnIds" | "column_ids" => Ok(GeneratedField::ColumnIds),
2166                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2167                        }
2168                    }
2169                }
2170                deserializer.deserialize_identifier(GeneratedVisitor)
2171            }
2172        }
2173        struct GeneratedVisitor;
2174        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2175            type Value = BatchPlanNode;
2176
2177            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2178                formatter.write_str("struct stream_plan.BatchPlanNode")
2179            }
2180
2181            fn visit_map<V>(self, mut map_: V) -> std::result::Result<BatchPlanNode, V::Error>
2182                where
2183                    V: serde::de::MapAccess<'de>,
2184            {
2185                let mut table_desc__ = None;
2186                let mut column_ids__ = None;
2187                while let Some(k) = map_.next_key()? {
2188                    match k {
2189                        GeneratedField::TableDesc => {
2190                            if table_desc__.is_some() {
2191                                return Err(serde::de::Error::duplicate_field("tableDesc"));
2192                            }
2193                            table_desc__ = map_.next_value()?;
2194                        }
2195                        GeneratedField::ColumnIds => {
2196                            if column_ids__.is_some() {
2197                                return Err(serde::de::Error::duplicate_field("columnIds"));
2198                            }
2199                            column_ids__ = 
2200                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2201                                    .into_iter().map(|x| x.0).collect())
2202                            ;
2203                        }
2204                    }
2205                }
2206                Ok(BatchPlanNode {
2207                    table_desc: table_desc__,
2208                    column_ids: column_ids__.unwrap_or_default(),
2209                })
2210            }
2211        }
2212        deserializer.deserialize_struct("stream_plan.BatchPlanNode", FIELDS, GeneratedVisitor)
2213    }
2214}
2215impl serde::Serialize for CdcFilterNode {
2216    #[allow(deprecated)]
2217    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2218    where
2219        S: serde::Serializer,
2220    {
2221        use serde::ser::SerializeStruct;
2222        let mut len = 0;
2223        if self.search_condition.is_some() {
2224            len += 1;
2225        }
2226        if self.upstream_source_id != 0 {
2227            len += 1;
2228        }
2229        let mut struct_ser = serializer.serialize_struct("stream_plan.CdcFilterNode", len)?;
2230        if let Some(v) = self.search_condition.as_ref() {
2231            struct_ser.serialize_field("searchCondition", v)?;
2232        }
2233        if self.upstream_source_id != 0 {
2234            struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
2235        }
2236        struct_ser.end()
2237    }
2238}
2239impl<'de> serde::Deserialize<'de> for CdcFilterNode {
2240    #[allow(deprecated)]
2241    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2242    where
2243        D: serde::Deserializer<'de>,
2244    {
2245        const FIELDS: &[&str] = &[
2246            "search_condition",
2247            "searchCondition",
2248            "upstream_source_id",
2249            "upstreamSourceId",
2250        ];
2251
2252        #[allow(clippy::enum_variant_names)]
2253        enum GeneratedField {
2254            SearchCondition,
2255            UpstreamSourceId,
2256        }
2257        impl<'de> serde::Deserialize<'de> for GeneratedField {
2258            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2259            where
2260                D: serde::Deserializer<'de>,
2261            {
2262                struct GeneratedVisitor;
2263
2264                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2265                    type Value = GeneratedField;
2266
2267                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2268                        write!(formatter, "expected one of: {:?}", &FIELDS)
2269                    }
2270
2271                    #[allow(unused_variables)]
2272                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2273                    where
2274                        E: serde::de::Error,
2275                    {
2276                        match value {
2277                            "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
2278                            "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
2279                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2280                        }
2281                    }
2282                }
2283                deserializer.deserialize_identifier(GeneratedVisitor)
2284            }
2285        }
2286        struct GeneratedVisitor;
2287        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2288            type Value = CdcFilterNode;
2289
2290            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2291                formatter.write_str("struct stream_plan.CdcFilterNode")
2292            }
2293
2294            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CdcFilterNode, V::Error>
2295                where
2296                    V: serde::de::MapAccess<'de>,
2297            {
2298                let mut search_condition__ = None;
2299                let mut upstream_source_id__ = None;
2300                while let Some(k) = map_.next_key()? {
2301                    match k {
2302                        GeneratedField::SearchCondition => {
2303                            if search_condition__.is_some() {
2304                                return Err(serde::de::Error::duplicate_field("searchCondition"));
2305                            }
2306                            search_condition__ = map_.next_value()?;
2307                        }
2308                        GeneratedField::UpstreamSourceId => {
2309                            if upstream_source_id__.is_some() {
2310                                return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
2311                            }
2312                            upstream_source_id__ = 
2313                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
2314                            ;
2315                        }
2316                    }
2317                }
2318                Ok(CdcFilterNode {
2319                    search_condition: search_condition__,
2320                    upstream_source_id: upstream_source_id__.unwrap_or_default(),
2321                })
2322            }
2323        }
2324        deserializer.deserialize_struct("stream_plan.CdcFilterNode", FIELDS, GeneratedVisitor)
2325    }
2326}
2327impl serde::Serialize for ChangeLogNode {
2328    #[allow(deprecated)]
2329    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2330    where
2331        S: serde::Serializer,
2332    {
2333        use serde::ser::SerializeStruct;
2334        let mut len = 0;
2335        if self.need_op {
2336            len += 1;
2337        }
2338        let mut struct_ser = serializer.serialize_struct("stream_plan.ChangeLogNode", len)?;
2339        if self.need_op {
2340            struct_ser.serialize_field("needOp", &self.need_op)?;
2341        }
2342        struct_ser.end()
2343    }
2344}
2345impl<'de> serde::Deserialize<'de> for ChangeLogNode {
2346    #[allow(deprecated)]
2347    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2348    where
2349        D: serde::Deserializer<'de>,
2350    {
2351        const FIELDS: &[&str] = &[
2352            "need_op",
2353            "needOp",
2354        ];
2355
2356        #[allow(clippy::enum_variant_names)]
2357        enum GeneratedField {
2358            NeedOp,
2359        }
2360        impl<'de> serde::Deserialize<'de> for GeneratedField {
2361            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2362            where
2363                D: serde::Deserializer<'de>,
2364            {
2365                struct GeneratedVisitor;
2366
2367                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2368                    type Value = GeneratedField;
2369
2370                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2371                        write!(formatter, "expected one of: {:?}", &FIELDS)
2372                    }
2373
2374                    #[allow(unused_variables)]
2375                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2376                    where
2377                        E: serde::de::Error,
2378                    {
2379                        match value {
2380                            "needOp" | "need_op" => Ok(GeneratedField::NeedOp),
2381                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2382                        }
2383                    }
2384                }
2385                deserializer.deserialize_identifier(GeneratedVisitor)
2386            }
2387        }
2388        struct GeneratedVisitor;
2389        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2390            type Value = ChangeLogNode;
2391
2392            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2393                formatter.write_str("struct stream_plan.ChangeLogNode")
2394            }
2395
2396            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ChangeLogNode, V::Error>
2397                where
2398                    V: serde::de::MapAccess<'de>,
2399            {
2400                let mut need_op__ = None;
2401                while let Some(k) = map_.next_key()? {
2402                    match k {
2403                        GeneratedField::NeedOp => {
2404                            if need_op__.is_some() {
2405                                return Err(serde::de::Error::duplicate_field("needOp"));
2406                            }
2407                            need_op__ = Some(map_.next_value()?);
2408                        }
2409                    }
2410                }
2411                Ok(ChangeLogNode {
2412                    need_op: need_op__.unwrap_or_default(),
2413                })
2414            }
2415        }
2416        deserializer.deserialize_struct("stream_plan.ChangeLogNode", FIELDS, GeneratedVisitor)
2417    }
2418}
2419impl serde::Serialize for CombinedMutation {
2420    #[allow(deprecated)]
2421    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2422    where
2423        S: serde::Serializer,
2424    {
2425        use serde::ser::SerializeStruct;
2426        let mut len = 0;
2427        if !self.mutations.is_empty() {
2428            len += 1;
2429        }
2430        let mut struct_ser = serializer.serialize_struct("stream_plan.CombinedMutation", len)?;
2431        if !self.mutations.is_empty() {
2432            struct_ser.serialize_field("mutations", &self.mutations)?;
2433        }
2434        struct_ser.end()
2435    }
2436}
2437impl<'de> serde::Deserialize<'de> for CombinedMutation {
2438    #[allow(deprecated)]
2439    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2440    where
2441        D: serde::Deserializer<'de>,
2442    {
2443        const FIELDS: &[&str] = &[
2444            "mutations",
2445        ];
2446
2447        #[allow(clippy::enum_variant_names)]
2448        enum GeneratedField {
2449            Mutations,
2450        }
2451        impl<'de> serde::Deserialize<'de> for GeneratedField {
2452            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2453            where
2454                D: serde::Deserializer<'de>,
2455            {
2456                struct GeneratedVisitor;
2457
2458                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2459                    type Value = GeneratedField;
2460
2461                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2462                        write!(formatter, "expected one of: {:?}", &FIELDS)
2463                    }
2464
2465                    #[allow(unused_variables)]
2466                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2467                    where
2468                        E: serde::de::Error,
2469                    {
2470                        match value {
2471                            "mutations" => Ok(GeneratedField::Mutations),
2472                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2473                        }
2474                    }
2475                }
2476                deserializer.deserialize_identifier(GeneratedVisitor)
2477            }
2478        }
2479        struct GeneratedVisitor;
2480        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2481            type Value = CombinedMutation;
2482
2483            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2484                formatter.write_str("struct stream_plan.CombinedMutation")
2485            }
2486
2487            fn visit_map<V>(self, mut map_: V) -> std::result::Result<CombinedMutation, V::Error>
2488                where
2489                    V: serde::de::MapAccess<'de>,
2490            {
2491                let mut mutations__ = None;
2492                while let Some(k) = map_.next_key()? {
2493                    match k {
2494                        GeneratedField::Mutations => {
2495                            if mutations__.is_some() {
2496                                return Err(serde::de::Error::duplicate_field("mutations"));
2497                            }
2498                            mutations__ = Some(map_.next_value()?);
2499                        }
2500                    }
2501                }
2502                Ok(CombinedMutation {
2503                    mutations: mutations__.unwrap_or_default(),
2504                })
2505            }
2506        }
2507        deserializer.deserialize_struct("stream_plan.CombinedMutation", FIELDS, GeneratedVisitor)
2508    }
2509}
2510impl serde::Serialize for ConnectorPropsChangeMutation {
2511    #[allow(deprecated)]
2512    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2513    where
2514        S: serde::Serializer,
2515    {
2516        use serde::ser::SerializeStruct;
2517        let mut len = 0;
2518        if !self.connector_props_infos.is_empty() {
2519            len += 1;
2520        }
2521        let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation", len)?;
2522        if !self.connector_props_infos.is_empty() {
2523            struct_ser.serialize_field("connectorPropsInfos", &self.connector_props_infos)?;
2524        }
2525        struct_ser.end()
2526    }
2527}
2528impl<'de> serde::Deserialize<'de> for ConnectorPropsChangeMutation {
2529    #[allow(deprecated)]
2530    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2531    where
2532        D: serde::Deserializer<'de>,
2533    {
2534        const FIELDS: &[&str] = &[
2535            "connector_props_infos",
2536            "connectorPropsInfos",
2537        ];
2538
2539        #[allow(clippy::enum_variant_names)]
2540        enum GeneratedField {
2541            ConnectorPropsInfos,
2542        }
2543        impl<'de> serde::Deserialize<'de> for GeneratedField {
2544            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2545            where
2546                D: serde::Deserializer<'de>,
2547            {
2548                struct GeneratedVisitor;
2549
2550                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2551                    type Value = GeneratedField;
2552
2553                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2554                        write!(formatter, "expected one of: {:?}", &FIELDS)
2555                    }
2556
2557                    #[allow(unused_variables)]
2558                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2559                    where
2560                        E: serde::de::Error,
2561                    {
2562                        match value {
2563                            "connectorPropsInfos" | "connector_props_infos" => Ok(GeneratedField::ConnectorPropsInfos),
2564                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2565                        }
2566                    }
2567                }
2568                deserializer.deserialize_identifier(GeneratedVisitor)
2569            }
2570        }
2571        struct GeneratedVisitor;
2572        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2573            type Value = ConnectorPropsChangeMutation;
2574
2575            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2576                formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation")
2577            }
2578
2579            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ConnectorPropsChangeMutation, V::Error>
2580                where
2581                    V: serde::de::MapAccess<'de>,
2582            {
2583                let mut connector_props_infos__ = None;
2584                while let Some(k) = map_.next_key()? {
2585                    match k {
2586                        GeneratedField::ConnectorPropsInfos => {
2587                            if connector_props_infos__.is_some() {
2588                                return Err(serde::de::Error::duplicate_field("connectorPropsInfos"));
2589                            }
2590                            connector_props_infos__ = Some(
2591                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
2592                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
2593                            );
2594                        }
2595                    }
2596                }
2597                Ok(ConnectorPropsChangeMutation {
2598                    connector_props_infos: connector_props_infos__.unwrap_or_default(),
2599                })
2600            }
2601        }
2602        deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation", FIELDS, GeneratedVisitor)
2603    }
2604}
2605impl serde::Serialize for connector_props_change_mutation::ConnectorPropsInfo {
2606    #[allow(deprecated)]
2607    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2608    where
2609        S: serde::Serializer,
2610    {
2611        use serde::ser::SerializeStruct;
2612        let mut len = 0;
2613        if !self.connector_props_info.is_empty() {
2614            len += 1;
2615        }
2616        let mut struct_ser = serializer.serialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", len)?;
2617        if !self.connector_props_info.is_empty() {
2618            struct_ser.serialize_field("connectorPropsInfo", &self.connector_props_info)?;
2619        }
2620        struct_ser.end()
2621    }
2622}
2623impl<'de> serde::Deserialize<'de> for connector_props_change_mutation::ConnectorPropsInfo {
2624    #[allow(deprecated)]
2625    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2626    where
2627        D: serde::Deserializer<'de>,
2628    {
2629        const FIELDS: &[&str] = &[
2630            "connector_props_info",
2631            "connectorPropsInfo",
2632        ];
2633
2634        #[allow(clippy::enum_variant_names)]
2635        enum GeneratedField {
2636            ConnectorPropsInfo,
2637        }
2638        impl<'de> serde::Deserialize<'de> for GeneratedField {
2639            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2640            where
2641                D: serde::Deserializer<'de>,
2642            {
2643                struct GeneratedVisitor;
2644
2645                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2646                    type Value = GeneratedField;
2647
2648                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2649                        write!(formatter, "expected one of: {:?}", &FIELDS)
2650                    }
2651
2652                    #[allow(unused_variables)]
2653                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2654                    where
2655                        E: serde::de::Error,
2656                    {
2657                        match value {
2658                            "connectorPropsInfo" | "connector_props_info" => Ok(GeneratedField::ConnectorPropsInfo),
2659                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2660                        }
2661                    }
2662                }
2663                deserializer.deserialize_identifier(GeneratedVisitor)
2664            }
2665        }
2666        struct GeneratedVisitor;
2667        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2668            type Value = connector_props_change_mutation::ConnectorPropsInfo;
2669
2670            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2671                formatter.write_str("struct stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo")
2672            }
2673
2674            fn visit_map<V>(self, mut map_: V) -> std::result::Result<connector_props_change_mutation::ConnectorPropsInfo, V::Error>
2675                where
2676                    V: serde::de::MapAccess<'de>,
2677            {
2678                let mut connector_props_info__ = None;
2679                while let Some(k) = map_.next_key()? {
2680                    match k {
2681                        GeneratedField::ConnectorPropsInfo => {
2682                            if connector_props_info__.is_some() {
2683                                return Err(serde::de::Error::duplicate_field("connectorPropsInfo"));
2684                            }
2685                            connector_props_info__ = Some(
2686                                map_.next_value::<std::collections::HashMap<_, _>>()?
2687                            );
2688                        }
2689                    }
2690                }
2691                Ok(connector_props_change_mutation::ConnectorPropsInfo {
2692                    connector_props_info: connector_props_info__.unwrap_or_default(),
2693                })
2694            }
2695        }
2696        deserializer.deserialize_struct("stream_plan.ConnectorPropsChangeMutation.ConnectorPropsInfo", FIELDS, GeneratedVisitor)
2697    }
2698}
2699impl serde::Serialize for DedupNode {
2700    #[allow(deprecated)]
2701    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2702    where
2703        S: serde::Serializer,
2704    {
2705        use serde::ser::SerializeStruct;
2706        let mut len = 0;
2707        if self.state_table.is_some() {
2708            len += 1;
2709        }
2710        if !self.dedup_column_indices.is_empty() {
2711            len += 1;
2712        }
2713        let mut struct_ser = serializer.serialize_struct("stream_plan.DedupNode", len)?;
2714        if let Some(v) = self.state_table.as_ref() {
2715            struct_ser.serialize_field("stateTable", v)?;
2716        }
2717        if !self.dedup_column_indices.is_empty() {
2718            struct_ser.serialize_field("dedupColumnIndices", &self.dedup_column_indices)?;
2719        }
2720        struct_ser.end()
2721    }
2722}
2723impl<'de> serde::Deserialize<'de> for DedupNode {
2724    #[allow(deprecated)]
2725    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2726    where
2727        D: serde::Deserializer<'de>,
2728    {
2729        const FIELDS: &[&str] = &[
2730            "state_table",
2731            "stateTable",
2732            "dedup_column_indices",
2733            "dedupColumnIndices",
2734        ];
2735
2736        #[allow(clippy::enum_variant_names)]
2737        enum GeneratedField {
2738            StateTable,
2739            DedupColumnIndices,
2740        }
2741        impl<'de> serde::Deserialize<'de> for GeneratedField {
2742            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2743            where
2744                D: serde::Deserializer<'de>,
2745            {
2746                struct GeneratedVisitor;
2747
2748                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2749                    type Value = GeneratedField;
2750
2751                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2752                        write!(formatter, "expected one of: {:?}", &FIELDS)
2753                    }
2754
2755                    #[allow(unused_variables)]
2756                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2757                    where
2758                        E: serde::de::Error,
2759                    {
2760                        match value {
2761                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
2762                            "dedupColumnIndices" | "dedup_column_indices" => Ok(GeneratedField::DedupColumnIndices),
2763                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2764                        }
2765                    }
2766                }
2767                deserializer.deserialize_identifier(GeneratedVisitor)
2768            }
2769        }
2770        struct GeneratedVisitor;
2771        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2772            type Value = DedupNode;
2773
2774            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2775                formatter.write_str("struct stream_plan.DedupNode")
2776            }
2777
2778            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DedupNode, V::Error>
2779                where
2780                    V: serde::de::MapAccess<'de>,
2781            {
2782                let mut state_table__ = None;
2783                let mut dedup_column_indices__ = None;
2784                while let Some(k) = map_.next_key()? {
2785                    match k {
2786                        GeneratedField::StateTable => {
2787                            if state_table__.is_some() {
2788                                return Err(serde::de::Error::duplicate_field("stateTable"));
2789                            }
2790                            state_table__ = map_.next_value()?;
2791                        }
2792                        GeneratedField::DedupColumnIndices => {
2793                            if dedup_column_indices__.is_some() {
2794                                return Err(serde::de::Error::duplicate_field("dedupColumnIndices"));
2795                            }
2796                            dedup_column_indices__ = 
2797                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
2798                                    .into_iter().map(|x| x.0).collect())
2799                            ;
2800                        }
2801                    }
2802                }
2803                Ok(DedupNode {
2804                    state_table: state_table__,
2805                    dedup_column_indices: dedup_column_indices__.unwrap_or_default(),
2806                })
2807            }
2808        }
2809        deserializer.deserialize_struct("stream_plan.DedupNode", FIELDS, GeneratedVisitor)
2810    }
2811}
2812impl serde::Serialize for DeltaExpression {
2813    #[allow(deprecated)]
2814    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2815    where
2816        S: serde::Serializer,
2817    {
2818        use serde::ser::SerializeStruct;
2819        let mut len = 0;
2820        if self.delta_type != 0 {
2821            len += 1;
2822        }
2823        if self.delta.is_some() {
2824            len += 1;
2825        }
2826        let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaExpression", len)?;
2827        if self.delta_type != 0 {
2828            let v = super::expr::expr_node::Type::try_from(self.delta_type)
2829                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.delta_type)))?;
2830            struct_ser.serialize_field("deltaType", &v)?;
2831        }
2832        if let Some(v) = self.delta.as_ref() {
2833            struct_ser.serialize_field("delta", v)?;
2834        }
2835        struct_ser.end()
2836    }
2837}
2838impl<'de> serde::Deserialize<'de> for DeltaExpression {
2839    #[allow(deprecated)]
2840    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2841    where
2842        D: serde::Deserializer<'de>,
2843    {
2844        const FIELDS: &[&str] = &[
2845            "delta_type",
2846            "deltaType",
2847            "delta",
2848        ];
2849
2850        #[allow(clippy::enum_variant_names)]
2851        enum GeneratedField {
2852            DeltaType,
2853            Delta,
2854        }
2855        impl<'de> serde::Deserialize<'de> for GeneratedField {
2856            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
2857            where
2858                D: serde::Deserializer<'de>,
2859            {
2860                struct GeneratedVisitor;
2861
2862                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2863                    type Value = GeneratedField;
2864
2865                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2866                        write!(formatter, "expected one of: {:?}", &FIELDS)
2867                    }
2868
2869                    #[allow(unused_variables)]
2870                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
2871                    where
2872                        E: serde::de::Error,
2873                    {
2874                        match value {
2875                            "deltaType" | "delta_type" => Ok(GeneratedField::DeltaType),
2876                            "delta" => Ok(GeneratedField::Delta),
2877                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
2878                        }
2879                    }
2880                }
2881                deserializer.deserialize_identifier(GeneratedVisitor)
2882            }
2883        }
2884        struct GeneratedVisitor;
2885        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
2886            type Value = DeltaExpression;
2887
2888            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2889                formatter.write_str("struct stream_plan.DeltaExpression")
2890            }
2891
2892            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaExpression, V::Error>
2893                where
2894                    V: serde::de::MapAccess<'de>,
2895            {
2896                let mut delta_type__ = None;
2897                let mut delta__ = None;
2898                while let Some(k) = map_.next_key()? {
2899                    match k {
2900                        GeneratedField::DeltaType => {
2901                            if delta_type__.is_some() {
2902                                return Err(serde::de::Error::duplicate_field("deltaType"));
2903                            }
2904                            delta_type__ = Some(map_.next_value::<super::expr::expr_node::Type>()? as i32);
2905                        }
2906                        GeneratedField::Delta => {
2907                            if delta__.is_some() {
2908                                return Err(serde::de::Error::duplicate_field("delta"));
2909                            }
2910                            delta__ = map_.next_value()?;
2911                        }
2912                    }
2913                }
2914                Ok(DeltaExpression {
2915                    delta_type: delta_type__.unwrap_or_default(),
2916                    delta: delta__,
2917                })
2918            }
2919        }
2920        deserializer.deserialize_struct("stream_plan.DeltaExpression", FIELDS, GeneratedVisitor)
2921    }
2922}
2923impl serde::Serialize for DeltaIndexJoinNode {
2924    #[allow(deprecated)]
2925    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
2926    where
2927        S: serde::Serializer,
2928    {
2929        use serde::ser::SerializeStruct;
2930        let mut len = 0;
2931        if self.join_type != 0 {
2932            len += 1;
2933        }
2934        if !self.left_key.is_empty() {
2935            len += 1;
2936        }
2937        if !self.right_key.is_empty() {
2938            len += 1;
2939        }
2940        if self.condition.is_some() {
2941            len += 1;
2942        }
2943        if self.left_table_id != 0 {
2944            len += 1;
2945        }
2946        if self.right_table_id != 0 {
2947            len += 1;
2948        }
2949        if self.left_info.is_some() {
2950            len += 1;
2951        }
2952        if self.right_info.is_some() {
2953            len += 1;
2954        }
2955        if !self.output_indices.is_empty() {
2956            len += 1;
2957        }
2958        let mut struct_ser = serializer.serialize_struct("stream_plan.DeltaIndexJoinNode", len)?;
2959        if self.join_type != 0 {
2960            let v = super::plan_common::JoinType::try_from(self.join_type)
2961                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
2962            struct_ser.serialize_field("joinType", &v)?;
2963        }
2964        if !self.left_key.is_empty() {
2965            struct_ser.serialize_field("leftKey", &self.left_key)?;
2966        }
2967        if !self.right_key.is_empty() {
2968            struct_ser.serialize_field("rightKey", &self.right_key)?;
2969        }
2970        if let Some(v) = self.condition.as_ref() {
2971            struct_ser.serialize_field("condition", v)?;
2972        }
2973        if self.left_table_id != 0 {
2974            struct_ser.serialize_field("leftTableId", &self.left_table_id)?;
2975        }
2976        if self.right_table_id != 0 {
2977            struct_ser.serialize_field("rightTableId", &self.right_table_id)?;
2978        }
2979        if let Some(v) = self.left_info.as_ref() {
2980            struct_ser.serialize_field("leftInfo", v)?;
2981        }
2982        if let Some(v) = self.right_info.as_ref() {
2983            struct_ser.serialize_field("rightInfo", v)?;
2984        }
2985        if !self.output_indices.is_empty() {
2986            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
2987        }
2988        struct_ser.end()
2989    }
2990}
2991impl<'de> serde::Deserialize<'de> for DeltaIndexJoinNode {
2992    #[allow(deprecated)]
2993    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
2994    where
2995        D: serde::Deserializer<'de>,
2996    {
2997        const FIELDS: &[&str] = &[
2998            "join_type",
2999            "joinType",
3000            "left_key",
3001            "leftKey",
3002            "right_key",
3003            "rightKey",
3004            "condition",
3005            "left_table_id",
3006            "leftTableId",
3007            "right_table_id",
3008            "rightTableId",
3009            "left_info",
3010            "leftInfo",
3011            "right_info",
3012            "rightInfo",
3013            "output_indices",
3014            "outputIndices",
3015        ];
3016
3017        #[allow(clippy::enum_variant_names)]
3018        enum GeneratedField {
3019            JoinType,
3020            LeftKey,
3021            RightKey,
3022            Condition,
3023            LeftTableId,
3024            RightTableId,
3025            LeftInfo,
3026            RightInfo,
3027            OutputIndices,
3028        }
3029        impl<'de> serde::Deserialize<'de> for GeneratedField {
3030            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3031            where
3032                D: serde::Deserializer<'de>,
3033            {
3034                struct GeneratedVisitor;
3035
3036                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3037                    type Value = GeneratedField;
3038
3039                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3040                        write!(formatter, "expected one of: {:?}", &FIELDS)
3041                    }
3042
3043                    #[allow(unused_variables)]
3044                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3045                    where
3046                        E: serde::de::Error,
3047                    {
3048                        match value {
3049                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
3050                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
3051                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
3052                            "condition" => Ok(GeneratedField::Condition),
3053                            "leftTableId" | "left_table_id" => Ok(GeneratedField::LeftTableId),
3054                            "rightTableId" | "right_table_id" => Ok(GeneratedField::RightTableId),
3055                            "leftInfo" | "left_info" => Ok(GeneratedField::LeftInfo),
3056                            "rightInfo" | "right_info" => Ok(GeneratedField::RightInfo),
3057                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
3058                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3059                        }
3060                    }
3061                }
3062                deserializer.deserialize_identifier(GeneratedVisitor)
3063            }
3064        }
3065        struct GeneratedVisitor;
3066        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3067            type Value = DeltaIndexJoinNode;
3068
3069            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3070                formatter.write_str("struct stream_plan.DeltaIndexJoinNode")
3071            }
3072
3073            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DeltaIndexJoinNode, V::Error>
3074                where
3075                    V: serde::de::MapAccess<'de>,
3076            {
3077                let mut join_type__ = None;
3078                let mut left_key__ = None;
3079                let mut right_key__ = None;
3080                let mut condition__ = None;
3081                let mut left_table_id__ = None;
3082                let mut right_table_id__ = None;
3083                let mut left_info__ = None;
3084                let mut right_info__ = None;
3085                let mut output_indices__ = None;
3086                while let Some(k) = map_.next_key()? {
3087                    match k {
3088                        GeneratedField::JoinType => {
3089                            if join_type__.is_some() {
3090                                return Err(serde::de::Error::duplicate_field("joinType"));
3091                            }
3092                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
3093                        }
3094                        GeneratedField::LeftKey => {
3095                            if left_key__.is_some() {
3096                                return Err(serde::de::Error::duplicate_field("leftKey"));
3097                            }
3098                            left_key__ = 
3099                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3100                                    .into_iter().map(|x| x.0).collect())
3101                            ;
3102                        }
3103                        GeneratedField::RightKey => {
3104                            if right_key__.is_some() {
3105                                return Err(serde::de::Error::duplicate_field("rightKey"));
3106                            }
3107                            right_key__ = 
3108                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3109                                    .into_iter().map(|x| x.0).collect())
3110                            ;
3111                        }
3112                        GeneratedField::Condition => {
3113                            if condition__.is_some() {
3114                                return Err(serde::de::Error::duplicate_field("condition"));
3115                            }
3116                            condition__ = map_.next_value()?;
3117                        }
3118                        GeneratedField::LeftTableId => {
3119                            if left_table_id__.is_some() {
3120                                return Err(serde::de::Error::duplicate_field("leftTableId"));
3121                            }
3122                            left_table_id__ = 
3123                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3124                            ;
3125                        }
3126                        GeneratedField::RightTableId => {
3127                            if right_table_id__.is_some() {
3128                                return Err(serde::de::Error::duplicate_field("rightTableId"));
3129                            }
3130                            right_table_id__ = 
3131                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3132                            ;
3133                        }
3134                        GeneratedField::LeftInfo => {
3135                            if left_info__.is_some() {
3136                                return Err(serde::de::Error::duplicate_field("leftInfo"));
3137                            }
3138                            left_info__ = map_.next_value()?;
3139                        }
3140                        GeneratedField::RightInfo => {
3141                            if right_info__.is_some() {
3142                                return Err(serde::de::Error::duplicate_field("rightInfo"));
3143                            }
3144                            right_info__ = map_.next_value()?;
3145                        }
3146                        GeneratedField::OutputIndices => {
3147                            if output_indices__.is_some() {
3148                                return Err(serde::de::Error::duplicate_field("outputIndices"));
3149                            }
3150                            output_indices__ = 
3151                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3152                                    .into_iter().map(|x| x.0).collect())
3153                            ;
3154                        }
3155                    }
3156                }
3157                Ok(DeltaIndexJoinNode {
3158                    join_type: join_type__.unwrap_or_default(),
3159                    left_key: left_key__.unwrap_or_default(),
3160                    right_key: right_key__.unwrap_or_default(),
3161                    condition: condition__,
3162                    left_table_id: left_table_id__.unwrap_or_default(),
3163                    right_table_id: right_table_id__.unwrap_or_default(),
3164                    left_info: left_info__,
3165                    right_info: right_info__,
3166                    output_indices: output_indices__.unwrap_or_default(),
3167                })
3168            }
3169        }
3170        deserializer.deserialize_struct("stream_plan.DeltaIndexJoinNode", FIELDS, GeneratedVisitor)
3171    }
3172}
3173impl serde::Serialize for DispatchOutputMapping {
3174    #[allow(deprecated)]
3175    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3176    where
3177        S: serde::Serializer,
3178    {
3179        use serde::ser::SerializeStruct;
3180        let mut len = 0;
3181        if !self.indices.is_empty() {
3182            len += 1;
3183        }
3184        if !self.types.is_empty() {
3185            len += 1;
3186        }
3187        let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping", len)?;
3188        if !self.indices.is_empty() {
3189            struct_ser.serialize_field("indices", &self.indices)?;
3190        }
3191        if !self.types.is_empty() {
3192            struct_ser.serialize_field("types", &self.types)?;
3193        }
3194        struct_ser.end()
3195    }
3196}
3197impl<'de> serde::Deserialize<'de> for DispatchOutputMapping {
3198    #[allow(deprecated)]
3199    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3200    where
3201        D: serde::Deserializer<'de>,
3202    {
3203        const FIELDS: &[&str] = &[
3204            "indices",
3205            "types",
3206        ];
3207
3208        #[allow(clippy::enum_variant_names)]
3209        enum GeneratedField {
3210            Indices,
3211            Types,
3212        }
3213        impl<'de> serde::Deserialize<'de> for GeneratedField {
3214            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3215            where
3216                D: serde::Deserializer<'de>,
3217            {
3218                struct GeneratedVisitor;
3219
3220                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3221                    type Value = GeneratedField;
3222
3223                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3224                        write!(formatter, "expected one of: {:?}", &FIELDS)
3225                    }
3226
3227                    #[allow(unused_variables)]
3228                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3229                    where
3230                        E: serde::de::Error,
3231                    {
3232                        match value {
3233                            "indices" => Ok(GeneratedField::Indices),
3234                            "types" => Ok(GeneratedField::Types),
3235                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3236                        }
3237                    }
3238                }
3239                deserializer.deserialize_identifier(GeneratedVisitor)
3240            }
3241        }
3242        struct GeneratedVisitor;
3243        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3244            type Value = DispatchOutputMapping;
3245
3246            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3247                formatter.write_str("struct stream_plan.DispatchOutputMapping")
3248            }
3249
3250            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchOutputMapping, V::Error>
3251                where
3252                    V: serde::de::MapAccess<'de>,
3253            {
3254                let mut indices__ = None;
3255                let mut types__ = None;
3256                while let Some(k) = map_.next_key()? {
3257                    match k {
3258                        GeneratedField::Indices => {
3259                            if indices__.is_some() {
3260                                return Err(serde::de::Error::duplicate_field("indices"));
3261                            }
3262                            indices__ = 
3263                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3264                                    .into_iter().map(|x| x.0).collect())
3265                            ;
3266                        }
3267                        GeneratedField::Types => {
3268                            if types__.is_some() {
3269                                return Err(serde::de::Error::duplicate_field("types"));
3270                            }
3271                            types__ = Some(map_.next_value()?);
3272                        }
3273                    }
3274                }
3275                Ok(DispatchOutputMapping {
3276                    indices: indices__.unwrap_or_default(),
3277                    types: types__.unwrap_or_default(),
3278                })
3279            }
3280        }
3281        deserializer.deserialize_struct("stream_plan.DispatchOutputMapping", FIELDS, GeneratedVisitor)
3282    }
3283}
3284impl serde::Serialize for dispatch_output_mapping::TypePair {
3285    #[allow(deprecated)]
3286    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3287    where
3288        S: serde::Serializer,
3289    {
3290        use serde::ser::SerializeStruct;
3291        let mut len = 0;
3292        if self.upstream.is_some() {
3293            len += 1;
3294        }
3295        if self.downstream.is_some() {
3296            len += 1;
3297        }
3298        let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchOutputMapping.TypePair", len)?;
3299        if let Some(v) = self.upstream.as_ref() {
3300            struct_ser.serialize_field("upstream", v)?;
3301        }
3302        if let Some(v) = self.downstream.as_ref() {
3303            struct_ser.serialize_field("downstream", v)?;
3304        }
3305        struct_ser.end()
3306    }
3307}
3308impl<'de> serde::Deserialize<'de> for dispatch_output_mapping::TypePair {
3309    #[allow(deprecated)]
3310    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3311    where
3312        D: serde::Deserializer<'de>,
3313    {
3314        const FIELDS: &[&str] = &[
3315            "upstream",
3316            "downstream",
3317        ];
3318
3319        #[allow(clippy::enum_variant_names)]
3320        enum GeneratedField {
3321            Upstream,
3322            Downstream,
3323        }
3324        impl<'de> serde::Deserialize<'de> for GeneratedField {
3325            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3326            where
3327                D: serde::Deserializer<'de>,
3328            {
3329                struct GeneratedVisitor;
3330
3331                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3332                    type Value = GeneratedField;
3333
3334                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3335                        write!(formatter, "expected one of: {:?}", &FIELDS)
3336                    }
3337
3338                    #[allow(unused_variables)]
3339                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3340                    where
3341                        E: serde::de::Error,
3342                    {
3343                        match value {
3344                            "upstream" => Ok(GeneratedField::Upstream),
3345                            "downstream" => Ok(GeneratedField::Downstream),
3346                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3347                        }
3348                    }
3349                }
3350                deserializer.deserialize_identifier(GeneratedVisitor)
3351            }
3352        }
3353        struct GeneratedVisitor;
3354        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3355            type Value = dispatch_output_mapping::TypePair;
3356
3357            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3358                formatter.write_str("struct stream_plan.DispatchOutputMapping.TypePair")
3359            }
3360
3361            fn visit_map<V>(self, mut map_: V) -> std::result::Result<dispatch_output_mapping::TypePair, V::Error>
3362                where
3363                    V: serde::de::MapAccess<'de>,
3364            {
3365                let mut upstream__ = None;
3366                let mut downstream__ = None;
3367                while let Some(k) = map_.next_key()? {
3368                    match k {
3369                        GeneratedField::Upstream => {
3370                            if upstream__.is_some() {
3371                                return Err(serde::de::Error::duplicate_field("upstream"));
3372                            }
3373                            upstream__ = map_.next_value()?;
3374                        }
3375                        GeneratedField::Downstream => {
3376                            if downstream__.is_some() {
3377                                return Err(serde::de::Error::duplicate_field("downstream"));
3378                            }
3379                            downstream__ = map_.next_value()?;
3380                        }
3381                    }
3382                }
3383                Ok(dispatch_output_mapping::TypePair {
3384                    upstream: upstream__,
3385                    downstream: downstream__,
3386                })
3387            }
3388        }
3389        deserializer.deserialize_struct("stream_plan.DispatchOutputMapping.TypePair", FIELDS, GeneratedVisitor)
3390    }
3391}
3392impl serde::Serialize for DispatchStrategy {
3393    #[allow(deprecated)]
3394    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3395    where
3396        S: serde::Serializer,
3397    {
3398        use serde::ser::SerializeStruct;
3399        let mut len = 0;
3400        if self.r#type != 0 {
3401            len += 1;
3402        }
3403        if !self.dist_key_indices.is_empty() {
3404            len += 1;
3405        }
3406        if self.output_mapping.is_some() {
3407            len += 1;
3408        }
3409        let mut struct_ser = serializer.serialize_struct("stream_plan.DispatchStrategy", len)?;
3410        if self.r#type != 0 {
3411            let v = DispatcherType::try_from(self.r#type)
3412                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3413            struct_ser.serialize_field("type", &v)?;
3414        }
3415        if !self.dist_key_indices.is_empty() {
3416            struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3417        }
3418        if let Some(v) = self.output_mapping.as_ref() {
3419            struct_ser.serialize_field("outputMapping", v)?;
3420        }
3421        struct_ser.end()
3422    }
3423}
3424impl<'de> serde::Deserialize<'de> for DispatchStrategy {
3425    #[allow(deprecated)]
3426    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3427    where
3428        D: serde::Deserializer<'de>,
3429    {
3430        const FIELDS: &[&str] = &[
3431            "type",
3432            "dist_key_indices",
3433            "distKeyIndices",
3434            "output_mapping",
3435            "outputMapping",
3436        ];
3437
3438        #[allow(clippy::enum_variant_names)]
3439        enum GeneratedField {
3440            Type,
3441            DistKeyIndices,
3442            OutputMapping,
3443        }
3444        impl<'de> serde::Deserialize<'de> for GeneratedField {
3445            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3446            where
3447                D: serde::Deserializer<'de>,
3448            {
3449                struct GeneratedVisitor;
3450
3451                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3452                    type Value = GeneratedField;
3453
3454                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3455                        write!(formatter, "expected one of: {:?}", &FIELDS)
3456                    }
3457
3458                    #[allow(unused_variables)]
3459                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3460                    where
3461                        E: serde::de::Error,
3462                    {
3463                        match value {
3464                            "type" => Ok(GeneratedField::Type),
3465                            "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3466                            "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3467                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3468                        }
3469                    }
3470                }
3471                deserializer.deserialize_identifier(GeneratedVisitor)
3472            }
3473        }
3474        struct GeneratedVisitor;
3475        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3476            type Value = DispatchStrategy;
3477
3478            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3479                formatter.write_str("struct stream_plan.DispatchStrategy")
3480            }
3481
3482            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DispatchStrategy, V::Error>
3483                where
3484                    V: serde::de::MapAccess<'de>,
3485            {
3486                let mut r#type__ = None;
3487                let mut dist_key_indices__ = None;
3488                let mut output_mapping__ = None;
3489                while let Some(k) = map_.next_key()? {
3490                    match k {
3491                        GeneratedField::Type => {
3492                            if r#type__.is_some() {
3493                                return Err(serde::de::Error::duplicate_field("type"));
3494                            }
3495                            r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3496                        }
3497                        GeneratedField::DistKeyIndices => {
3498                            if dist_key_indices__.is_some() {
3499                                return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3500                            }
3501                            dist_key_indices__ = 
3502                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3503                                    .into_iter().map(|x| x.0).collect())
3504                            ;
3505                        }
3506                        GeneratedField::OutputMapping => {
3507                            if output_mapping__.is_some() {
3508                                return Err(serde::de::Error::duplicate_field("outputMapping"));
3509                            }
3510                            output_mapping__ = map_.next_value()?;
3511                        }
3512                    }
3513                }
3514                Ok(DispatchStrategy {
3515                    r#type: r#type__.unwrap_or_default(),
3516                    dist_key_indices: dist_key_indices__.unwrap_or_default(),
3517                    output_mapping: output_mapping__,
3518                })
3519            }
3520        }
3521        deserializer.deserialize_struct("stream_plan.DispatchStrategy", FIELDS, GeneratedVisitor)
3522    }
3523}
3524impl serde::Serialize for Dispatcher {
3525    #[allow(deprecated)]
3526    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3527    where
3528        S: serde::Serializer,
3529    {
3530        use serde::ser::SerializeStruct;
3531        let mut len = 0;
3532        if self.r#type != 0 {
3533            len += 1;
3534        }
3535        if !self.dist_key_indices.is_empty() {
3536            len += 1;
3537        }
3538        if self.output_mapping.is_some() {
3539            len += 1;
3540        }
3541        if self.hash_mapping.is_some() {
3542            len += 1;
3543        }
3544        if self.dispatcher_id != 0 {
3545            len += 1;
3546        }
3547        if !self.downstream_actor_id.is_empty() {
3548            len += 1;
3549        }
3550        let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatcher", len)?;
3551        if self.r#type != 0 {
3552            let v = DispatcherType::try_from(self.r#type)
3553                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.r#type)))?;
3554            struct_ser.serialize_field("type", &v)?;
3555        }
3556        if !self.dist_key_indices.is_empty() {
3557            struct_ser.serialize_field("distKeyIndices", &self.dist_key_indices)?;
3558        }
3559        if let Some(v) = self.output_mapping.as_ref() {
3560            struct_ser.serialize_field("outputMapping", v)?;
3561        }
3562        if let Some(v) = self.hash_mapping.as_ref() {
3563            struct_ser.serialize_field("hashMapping", v)?;
3564        }
3565        if self.dispatcher_id != 0 {
3566            #[allow(clippy::needless_borrow)]
3567            #[allow(clippy::needless_borrows_for_generic_args)]
3568            struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
3569        }
3570        if !self.downstream_actor_id.is_empty() {
3571            struct_ser.serialize_field("downstreamActorId", &self.downstream_actor_id)?;
3572        }
3573        struct_ser.end()
3574    }
3575}
3576impl<'de> serde::Deserialize<'de> for Dispatcher {
3577    #[allow(deprecated)]
3578    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3579    where
3580        D: serde::Deserializer<'de>,
3581    {
3582        const FIELDS: &[&str] = &[
3583            "type",
3584            "dist_key_indices",
3585            "distKeyIndices",
3586            "output_mapping",
3587            "outputMapping",
3588            "hash_mapping",
3589            "hashMapping",
3590            "dispatcher_id",
3591            "dispatcherId",
3592            "downstream_actor_id",
3593            "downstreamActorId",
3594        ];
3595
3596        #[allow(clippy::enum_variant_names)]
3597        enum GeneratedField {
3598            Type,
3599            DistKeyIndices,
3600            OutputMapping,
3601            HashMapping,
3602            DispatcherId,
3603            DownstreamActorId,
3604        }
3605        impl<'de> serde::Deserialize<'de> for GeneratedField {
3606            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3607            where
3608                D: serde::Deserializer<'de>,
3609            {
3610                struct GeneratedVisitor;
3611
3612                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3613                    type Value = GeneratedField;
3614
3615                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3616                        write!(formatter, "expected one of: {:?}", &FIELDS)
3617                    }
3618
3619                    #[allow(unused_variables)]
3620                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3621                    where
3622                        E: serde::de::Error,
3623                    {
3624                        match value {
3625                            "type" => Ok(GeneratedField::Type),
3626                            "distKeyIndices" | "dist_key_indices" => Ok(GeneratedField::DistKeyIndices),
3627                            "outputMapping" | "output_mapping" => Ok(GeneratedField::OutputMapping),
3628                            "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
3629                            "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
3630                            "downstreamActorId" | "downstream_actor_id" => Ok(GeneratedField::DownstreamActorId),
3631                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3632                        }
3633                    }
3634                }
3635                deserializer.deserialize_identifier(GeneratedVisitor)
3636            }
3637        }
3638        struct GeneratedVisitor;
3639        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3640            type Value = Dispatcher;
3641
3642            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3643                formatter.write_str("struct stream_plan.Dispatcher")
3644            }
3645
3646            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatcher, V::Error>
3647                where
3648                    V: serde::de::MapAccess<'de>,
3649            {
3650                let mut r#type__ = None;
3651                let mut dist_key_indices__ = None;
3652                let mut output_mapping__ = None;
3653                let mut hash_mapping__ = None;
3654                let mut dispatcher_id__ = None;
3655                let mut downstream_actor_id__ = None;
3656                while let Some(k) = map_.next_key()? {
3657                    match k {
3658                        GeneratedField::Type => {
3659                            if r#type__.is_some() {
3660                                return Err(serde::de::Error::duplicate_field("type"));
3661                            }
3662                            r#type__ = Some(map_.next_value::<DispatcherType>()? as i32);
3663                        }
3664                        GeneratedField::DistKeyIndices => {
3665                            if dist_key_indices__.is_some() {
3666                                return Err(serde::de::Error::duplicate_field("distKeyIndices"));
3667                            }
3668                            dist_key_indices__ = 
3669                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3670                                    .into_iter().map(|x| x.0).collect())
3671                            ;
3672                        }
3673                        GeneratedField::OutputMapping => {
3674                            if output_mapping__.is_some() {
3675                                return Err(serde::de::Error::duplicate_field("outputMapping"));
3676                            }
3677                            output_mapping__ = map_.next_value()?;
3678                        }
3679                        GeneratedField::HashMapping => {
3680                            if hash_mapping__.is_some() {
3681                                return Err(serde::de::Error::duplicate_field("hashMapping"));
3682                            }
3683                            hash_mapping__ = map_.next_value()?;
3684                        }
3685                        GeneratedField::DispatcherId => {
3686                            if dispatcher_id__.is_some() {
3687                                return Err(serde::de::Error::duplicate_field("dispatcherId"));
3688                            }
3689                            dispatcher_id__ = 
3690                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
3691                            ;
3692                        }
3693                        GeneratedField::DownstreamActorId => {
3694                            if downstream_actor_id__.is_some() {
3695                                return Err(serde::de::Error::duplicate_field("downstreamActorId"));
3696                            }
3697                            downstream_actor_id__ = 
3698                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
3699                                    .into_iter().map(|x| x.0).collect())
3700                            ;
3701                        }
3702                    }
3703                }
3704                Ok(Dispatcher {
3705                    r#type: r#type__.unwrap_or_default(),
3706                    dist_key_indices: dist_key_indices__.unwrap_or_default(),
3707                    output_mapping: output_mapping__,
3708                    hash_mapping: hash_mapping__,
3709                    dispatcher_id: dispatcher_id__.unwrap_or_default(),
3710                    downstream_actor_id: downstream_actor_id__.unwrap_or_default(),
3711                })
3712            }
3713        }
3714        deserializer.deserialize_struct("stream_plan.Dispatcher", FIELDS, GeneratedVisitor)
3715    }
3716}
3717impl serde::Serialize for DispatcherType {
3718    #[allow(deprecated)]
3719    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3720    where
3721        S: serde::Serializer,
3722    {
3723        let variant = match self {
3724            Self::Unspecified => "DISPATCHER_TYPE_UNSPECIFIED",
3725            Self::Hash => "DISPATCHER_TYPE_HASH",
3726            Self::Broadcast => "DISPATCHER_TYPE_BROADCAST",
3727            Self::Simple => "DISPATCHER_TYPE_SIMPLE",
3728            Self::NoShuffle => "DISPATCHER_TYPE_NO_SHUFFLE",
3729        };
3730        serializer.serialize_str(variant)
3731    }
3732}
3733impl<'de> serde::Deserialize<'de> for DispatcherType {
3734    #[allow(deprecated)]
3735    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3736    where
3737        D: serde::Deserializer<'de>,
3738    {
3739        const FIELDS: &[&str] = &[
3740            "DISPATCHER_TYPE_UNSPECIFIED",
3741            "DISPATCHER_TYPE_HASH",
3742            "DISPATCHER_TYPE_BROADCAST",
3743            "DISPATCHER_TYPE_SIMPLE",
3744            "DISPATCHER_TYPE_NO_SHUFFLE",
3745        ];
3746
3747        struct GeneratedVisitor;
3748
3749        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3750            type Value = DispatcherType;
3751
3752            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3753                write!(formatter, "expected one of: {:?}", &FIELDS)
3754            }
3755
3756            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
3757            where
3758                E: serde::de::Error,
3759            {
3760                i32::try_from(v)
3761                    .ok()
3762                    .and_then(|x| x.try_into().ok())
3763                    .ok_or_else(|| {
3764                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
3765                    })
3766            }
3767
3768            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
3769            where
3770                E: serde::de::Error,
3771            {
3772                i32::try_from(v)
3773                    .ok()
3774                    .and_then(|x| x.try_into().ok())
3775                    .ok_or_else(|| {
3776                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
3777                    })
3778            }
3779
3780            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
3781            where
3782                E: serde::de::Error,
3783            {
3784                match value {
3785                    "DISPATCHER_TYPE_UNSPECIFIED" => Ok(DispatcherType::Unspecified),
3786                    "DISPATCHER_TYPE_HASH" => Ok(DispatcherType::Hash),
3787                    "DISPATCHER_TYPE_BROADCAST" => Ok(DispatcherType::Broadcast),
3788                    "DISPATCHER_TYPE_SIMPLE" => Ok(DispatcherType::Simple),
3789                    "DISPATCHER_TYPE_NO_SHUFFLE" => Ok(DispatcherType::NoShuffle),
3790                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
3791                }
3792            }
3793        }
3794        deserializer.deserialize_any(GeneratedVisitor)
3795    }
3796}
3797impl serde::Serialize for Dispatchers {
3798    #[allow(deprecated)]
3799    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3800    where
3801        S: serde::Serializer,
3802    {
3803        use serde::ser::SerializeStruct;
3804        let mut len = 0;
3805        if !self.dispatchers.is_empty() {
3806            len += 1;
3807        }
3808        let mut struct_ser = serializer.serialize_struct("stream_plan.Dispatchers", len)?;
3809        if !self.dispatchers.is_empty() {
3810            struct_ser.serialize_field("dispatchers", &self.dispatchers)?;
3811        }
3812        struct_ser.end()
3813    }
3814}
3815impl<'de> serde::Deserialize<'de> for Dispatchers {
3816    #[allow(deprecated)]
3817    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3818    where
3819        D: serde::Deserializer<'de>,
3820    {
3821        const FIELDS: &[&str] = &[
3822            "dispatchers",
3823        ];
3824
3825        #[allow(clippy::enum_variant_names)]
3826        enum GeneratedField {
3827            Dispatchers,
3828        }
3829        impl<'de> serde::Deserialize<'de> for GeneratedField {
3830            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3831            where
3832                D: serde::Deserializer<'de>,
3833            {
3834                struct GeneratedVisitor;
3835
3836                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3837                    type Value = GeneratedField;
3838
3839                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3840                        write!(formatter, "expected one of: {:?}", &FIELDS)
3841                    }
3842
3843                    #[allow(unused_variables)]
3844                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3845                    where
3846                        E: serde::de::Error,
3847                    {
3848                        match value {
3849                            "dispatchers" => Ok(GeneratedField::Dispatchers),
3850                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3851                        }
3852                    }
3853                }
3854                deserializer.deserialize_identifier(GeneratedVisitor)
3855            }
3856        }
3857        struct GeneratedVisitor;
3858        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3859            type Value = Dispatchers;
3860
3861            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3862                formatter.write_str("struct stream_plan.Dispatchers")
3863            }
3864
3865            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Dispatchers, V::Error>
3866                where
3867                    V: serde::de::MapAccess<'de>,
3868            {
3869                let mut dispatchers__ = None;
3870                while let Some(k) = map_.next_key()? {
3871                    match k {
3872                        GeneratedField::Dispatchers => {
3873                            if dispatchers__.is_some() {
3874                                return Err(serde::de::Error::duplicate_field("dispatchers"));
3875                            }
3876                            dispatchers__ = Some(map_.next_value()?);
3877                        }
3878                    }
3879                }
3880                Ok(Dispatchers {
3881                    dispatchers: dispatchers__.unwrap_or_default(),
3882                })
3883            }
3884        }
3885        deserializer.deserialize_struct("stream_plan.Dispatchers", FIELDS, GeneratedVisitor)
3886    }
3887}
3888impl serde::Serialize for DmlNode {
3889    #[allow(deprecated)]
3890    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
3891    where
3892        S: serde::Serializer,
3893    {
3894        use serde::ser::SerializeStruct;
3895        let mut len = 0;
3896        if self.table_id != 0 {
3897            len += 1;
3898        }
3899        if self.table_version_id != 0 {
3900            len += 1;
3901        }
3902        if !self.column_descs.is_empty() {
3903            len += 1;
3904        }
3905        if self.rate_limit.is_some() {
3906            len += 1;
3907        }
3908        let mut struct_ser = serializer.serialize_struct("stream_plan.DmlNode", len)?;
3909        if self.table_id != 0 {
3910            struct_ser.serialize_field("tableId", &self.table_id)?;
3911        }
3912        if self.table_version_id != 0 {
3913            #[allow(clippy::needless_borrow)]
3914            #[allow(clippy::needless_borrows_for_generic_args)]
3915            struct_ser.serialize_field("tableVersionId", ToString::to_string(&self.table_version_id).as_str())?;
3916        }
3917        if !self.column_descs.is_empty() {
3918            struct_ser.serialize_field("columnDescs", &self.column_descs)?;
3919        }
3920        if let Some(v) = self.rate_limit.as_ref() {
3921            struct_ser.serialize_field("rateLimit", v)?;
3922        }
3923        struct_ser.end()
3924    }
3925}
3926impl<'de> serde::Deserialize<'de> for DmlNode {
3927    #[allow(deprecated)]
3928    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
3929    where
3930        D: serde::Deserializer<'de>,
3931    {
3932        const FIELDS: &[&str] = &[
3933            "table_id",
3934            "tableId",
3935            "table_version_id",
3936            "tableVersionId",
3937            "column_descs",
3938            "columnDescs",
3939            "rate_limit",
3940            "rateLimit",
3941        ];
3942
3943        #[allow(clippy::enum_variant_names)]
3944        enum GeneratedField {
3945            TableId,
3946            TableVersionId,
3947            ColumnDescs,
3948            RateLimit,
3949        }
3950        impl<'de> serde::Deserialize<'de> for GeneratedField {
3951            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
3952            where
3953                D: serde::Deserializer<'de>,
3954            {
3955                struct GeneratedVisitor;
3956
3957                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3958                    type Value = GeneratedField;
3959
3960                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3961                        write!(formatter, "expected one of: {:?}", &FIELDS)
3962                    }
3963
3964                    #[allow(unused_variables)]
3965                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
3966                    where
3967                        E: serde::de::Error,
3968                    {
3969                        match value {
3970                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
3971                            "tableVersionId" | "table_version_id" => Ok(GeneratedField::TableVersionId),
3972                            "columnDescs" | "column_descs" => Ok(GeneratedField::ColumnDescs),
3973                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
3974                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
3975                        }
3976                    }
3977                }
3978                deserializer.deserialize_identifier(GeneratedVisitor)
3979            }
3980        }
3981        struct GeneratedVisitor;
3982        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
3983            type Value = DmlNode;
3984
3985            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3986                formatter.write_str("struct stream_plan.DmlNode")
3987            }
3988
3989            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DmlNode, V::Error>
3990                where
3991                    V: serde::de::MapAccess<'de>,
3992            {
3993                let mut table_id__ = None;
3994                let mut table_version_id__ = None;
3995                let mut column_descs__ = None;
3996                let mut rate_limit__ = None;
3997                while let Some(k) = map_.next_key()? {
3998                    match k {
3999                        GeneratedField::TableId => {
4000                            if table_id__.is_some() {
4001                                return Err(serde::de::Error::duplicate_field("tableId"));
4002                            }
4003                            table_id__ = 
4004                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4005                            ;
4006                        }
4007                        GeneratedField::TableVersionId => {
4008                            if table_version_id__.is_some() {
4009                                return Err(serde::de::Error::duplicate_field("tableVersionId"));
4010                            }
4011                            table_version_id__ = 
4012                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4013                            ;
4014                        }
4015                        GeneratedField::ColumnDescs => {
4016                            if column_descs__.is_some() {
4017                                return Err(serde::de::Error::duplicate_field("columnDescs"));
4018                            }
4019                            column_descs__ = Some(map_.next_value()?);
4020                        }
4021                        GeneratedField::RateLimit => {
4022                            if rate_limit__.is_some() {
4023                                return Err(serde::de::Error::duplicate_field("rateLimit"));
4024                            }
4025                            rate_limit__ = 
4026                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
4027                            ;
4028                        }
4029                    }
4030                }
4031                Ok(DmlNode {
4032                    table_id: table_id__.unwrap_or_default(),
4033                    table_version_id: table_version_id__.unwrap_or_default(),
4034                    column_descs: column_descs__.unwrap_or_default(),
4035                    rate_limit: rate_limit__,
4036                })
4037            }
4038        }
4039        deserializer.deserialize_struct("stream_plan.DmlNode", FIELDS, GeneratedVisitor)
4040    }
4041}
4042impl serde::Serialize for DropSubscriptionsMutation {
4043    #[allow(deprecated)]
4044    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4045    where
4046        S: serde::Serializer,
4047    {
4048        use serde::ser::SerializeStruct;
4049        let mut len = 0;
4050        if !self.info.is_empty() {
4051            len += 1;
4052        }
4053        let mut struct_ser = serializer.serialize_struct("stream_plan.DropSubscriptionsMutation", len)?;
4054        if !self.info.is_empty() {
4055            struct_ser.serialize_field("info", &self.info)?;
4056        }
4057        struct_ser.end()
4058    }
4059}
4060impl<'de> serde::Deserialize<'de> for DropSubscriptionsMutation {
4061    #[allow(deprecated)]
4062    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4063    where
4064        D: serde::Deserializer<'de>,
4065    {
4066        const FIELDS: &[&str] = &[
4067            "info",
4068        ];
4069
4070        #[allow(clippy::enum_variant_names)]
4071        enum GeneratedField {
4072            Info,
4073        }
4074        impl<'de> serde::Deserialize<'de> for GeneratedField {
4075            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4076            where
4077                D: serde::Deserializer<'de>,
4078            {
4079                struct GeneratedVisitor;
4080
4081                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4082                    type Value = GeneratedField;
4083
4084                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4085                        write!(formatter, "expected one of: {:?}", &FIELDS)
4086                    }
4087
4088                    #[allow(unused_variables)]
4089                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4090                    where
4091                        E: serde::de::Error,
4092                    {
4093                        match value {
4094                            "info" => Ok(GeneratedField::Info),
4095                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4096                        }
4097                    }
4098                }
4099                deserializer.deserialize_identifier(GeneratedVisitor)
4100            }
4101        }
4102        struct GeneratedVisitor;
4103        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4104            type Value = DropSubscriptionsMutation;
4105
4106            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4107                formatter.write_str("struct stream_plan.DropSubscriptionsMutation")
4108            }
4109
4110            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DropSubscriptionsMutation, V::Error>
4111                where
4112                    V: serde::de::MapAccess<'de>,
4113            {
4114                let mut info__ = None;
4115                while let Some(k) = map_.next_key()? {
4116                    match k {
4117                        GeneratedField::Info => {
4118                            if info__.is_some() {
4119                                return Err(serde::de::Error::duplicate_field("info"));
4120                            }
4121                            info__ = Some(map_.next_value()?);
4122                        }
4123                    }
4124                }
4125                Ok(DropSubscriptionsMutation {
4126                    info: info__.unwrap_or_default(),
4127                })
4128            }
4129        }
4130        deserializer.deserialize_struct("stream_plan.DropSubscriptionsMutation", FIELDS, GeneratedVisitor)
4131    }
4132}
4133impl serde::Serialize for DynamicFilterNode {
4134    #[allow(deprecated)]
4135    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4136    where
4137        S: serde::Serializer,
4138    {
4139        use serde::ser::SerializeStruct;
4140        let mut len = 0;
4141        if self.left_key != 0 {
4142            len += 1;
4143        }
4144        if self.condition.is_some() {
4145            len += 1;
4146        }
4147        if self.left_table.is_some() {
4148            len += 1;
4149        }
4150        if self.right_table.is_some() {
4151            len += 1;
4152        }
4153        if self.condition_always_relax {
4154            len += 1;
4155        }
4156        let mut struct_ser = serializer.serialize_struct("stream_plan.DynamicFilterNode", len)?;
4157        if self.left_key != 0 {
4158            struct_ser.serialize_field("leftKey", &self.left_key)?;
4159        }
4160        if let Some(v) = self.condition.as_ref() {
4161            struct_ser.serialize_field("condition", v)?;
4162        }
4163        if let Some(v) = self.left_table.as_ref() {
4164            struct_ser.serialize_field("leftTable", v)?;
4165        }
4166        if let Some(v) = self.right_table.as_ref() {
4167            struct_ser.serialize_field("rightTable", v)?;
4168        }
4169        if self.condition_always_relax {
4170            struct_ser.serialize_field("conditionAlwaysRelax", &self.condition_always_relax)?;
4171        }
4172        struct_ser.end()
4173    }
4174}
4175impl<'de> serde::Deserialize<'de> for DynamicFilterNode {
4176    #[allow(deprecated)]
4177    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4178    where
4179        D: serde::Deserializer<'de>,
4180    {
4181        const FIELDS: &[&str] = &[
4182            "left_key",
4183            "leftKey",
4184            "condition",
4185            "left_table",
4186            "leftTable",
4187            "right_table",
4188            "rightTable",
4189            "condition_always_relax",
4190            "conditionAlwaysRelax",
4191        ];
4192
4193        #[allow(clippy::enum_variant_names)]
4194        enum GeneratedField {
4195            LeftKey,
4196            Condition,
4197            LeftTable,
4198            RightTable,
4199            ConditionAlwaysRelax,
4200        }
4201        impl<'de> serde::Deserialize<'de> for GeneratedField {
4202            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4203            where
4204                D: serde::Deserializer<'de>,
4205            {
4206                struct GeneratedVisitor;
4207
4208                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4209                    type Value = GeneratedField;
4210
4211                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4212                        write!(formatter, "expected one of: {:?}", &FIELDS)
4213                    }
4214
4215                    #[allow(unused_variables)]
4216                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4217                    where
4218                        E: serde::de::Error,
4219                    {
4220                        match value {
4221                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
4222                            "condition" => Ok(GeneratedField::Condition),
4223                            "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
4224                            "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
4225                            "conditionAlwaysRelax" | "condition_always_relax" => Ok(GeneratedField::ConditionAlwaysRelax),
4226                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4227                        }
4228                    }
4229                }
4230                deserializer.deserialize_identifier(GeneratedVisitor)
4231            }
4232        }
4233        struct GeneratedVisitor;
4234        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4235            type Value = DynamicFilterNode;
4236
4237            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4238                formatter.write_str("struct stream_plan.DynamicFilterNode")
4239            }
4240
4241            fn visit_map<V>(self, mut map_: V) -> std::result::Result<DynamicFilterNode, V::Error>
4242                where
4243                    V: serde::de::MapAccess<'de>,
4244            {
4245                let mut left_key__ = None;
4246                let mut condition__ = None;
4247                let mut left_table__ = None;
4248                let mut right_table__ = None;
4249                let mut condition_always_relax__ = None;
4250                while let Some(k) = map_.next_key()? {
4251                    match k {
4252                        GeneratedField::LeftKey => {
4253                            if left_key__.is_some() {
4254                                return Err(serde::de::Error::duplicate_field("leftKey"));
4255                            }
4256                            left_key__ = 
4257                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4258                            ;
4259                        }
4260                        GeneratedField::Condition => {
4261                            if condition__.is_some() {
4262                                return Err(serde::de::Error::duplicate_field("condition"));
4263                            }
4264                            condition__ = map_.next_value()?;
4265                        }
4266                        GeneratedField::LeftTable => {
4267                            if left_table__.is_some() {
4268                                return Err(serde::de::Error::duplicate_field("leftTable"));
4269                            }
4270                            left_table__ = map_.next_value()?;
4271                        }
4272                        GeneratedField::RightTable => {
4273                            if right_table__.is_some() {
4274                                return Err(serde::de::Error::duplicate_field("rightTable"));
4275                            }
4276                            right_table__ = map_.next_value()?;
4277                        }
4278                        GeneratedField::ConditionAlwaysRelax => {
4279                            if condition_always_relax__.is_some() {
4280                                return Err(serde::de::Error::duplicate_field("conditionAlwaysRelax"));
4281                            }
4282                            condition_always_relax__ = Some(map_.next_value()?);
4283                        }
4284                    }
4285                }
4286                Ok(DynamicFilterNode {
4287                    left_key: left_key__.unwrap_or_default(),
4288                    condition: condition__,
4289                    left_table: left_table__,
4290                    right_table: right_table__,
4291                    condition_always_relax: condition_always_relax__.unwrap_or_default(),
4292                })
4293            }
4294        }
4295        deserializer.deserialize_struct("stream_plan.DynamicFilterNode", FIELDS, GeneratedVisitor)
4296    }
4297}
4298impl serde::Serialize for EowcOverWindowNode {
4299    #[allow(deprecated)]
4300    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4301    where
4302        S: serde::Serializer,
4303    {
4304        use serde::ser::SerializeStruct;
4305        let mut len = 0;
4306        if !self.calls.is_empty() {
4307            len += 1;
4308        }
4309        if !self.partition_by.is_empty() {
4310            len += 1;
4311        }
4312        if !self.order_by.is_empty() {
4313            len += 1;
4314        }
4315        if self.state_table.is_some() {
4316            len += 1;
4317        }
4318        let mut struct_ser = serializer.serialize_struct("stream_plan.EowcOverWindowNode", len)?;
4319        if !self.calls.is_empty() {
4320            struct_ser.serialize_field("calls", &self.calls)?;
4321        }
4322        if !self.partition_by.is_empty() {
4323            struct_ser.serialize_field("partitionBy", &self.partition_by)?;
4324        }
4325        if !self.order_by.is_empty() {
4326            struct_ser.serialize_field("orderBy", &self.order_by)?;
4327        }
4328        if let Some(v) = self.state_table.as_ref() {
4329            struct_ser.serialize_field("stateTable", v)?;
4330        }
4331        struct_ser.end()
4332    }
4333}
4334impl<'de> serde::Deserialize<'de> for EowcOverWindowNode {
4335    #[allow(deprecated)]
4336    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4337    where
4338        D: serde::Deserializer<'de>,
4339    {
4340        const FIELDS: &[&str] = &[
4341            "calls",
4342            "partition_by",
4343            "partitionBy",
4344            "order_by",
4345            "orderBy",
4346            "state_table",
4347            "stateTable",
4348        ];
4349
4350        #[allow(clippy::enum_variant_names)]
4351        enum GeneratedField {
4352            Calls,
4353            PartitionBy,
4354            OrderBy,
4355            StateTable,
4356        }
4357        impl<'de> serde::Deserialize<'de> for GeneratedField {
4358            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4359            where
4360                D: serde::Deserializer<'de>,
4361            {
4362                struct GeneratedVisitor;
4363
4364                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4365                    type Value = GeneratedField;
4366
4367                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4368                        write!(formatter, "expected one of: {:?}", &FIELDS)
4369                    }
4370
4371                    #[allow(unused_variables)]
4372                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4373                    where
4374                        E: serde::de::Error,
4375                    {
4376                        match value {
4377                            "calls" => Ok(GeneratedField::Calls),
4378                            "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
4379                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
4380                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
4381                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4382                        }
4383                    }
4384                }
4385                deserializer.deserialize_identifier(GeneratedVisitor)
4386            }
4387        }
4388        struct GeneratedVisitor;
4389        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4390            type Value = EowcOverWindowNode;
4391
4392            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4393                formatter.write_str("struct stream_plan.EowcOverWindowNode")
4394            }
4395
4396            fn visit_map<V>(self, mut map_: V) -> std::result::Result<EowcOverWindowNode, V::Error>
4397                where
4398                    V: serde::de::MapAccess<'de>,
4399            {
4400                let mut calls__ = None;
4401                let mut partition_by__ = None;
4402                let mut order_by__ = None;
4403                let mut state_table__ = None;
4404                while let Some(k) = map_.next_key()? {
4405                    match k {
4406                        GeneratedField::Calls => {
4407                            if calls__.is_some() {
4408                                return Err(serde::de::Error::duplicate_field("calls"));
4409                            }
4410                            calls__ = Some(map_.next_value()?);
4411                        }
4412                        GeneratedField::PartitionBy => {
4413                            if partition_by__.is_some() {
4414                                return Err(serde::de::Error::duplicate_field("partitionBy"));
4415                            }
4416                            partition_by__ = 
4417                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4418                                    .into_iter().map(|x| x.0).collect())
4419                            ;
4420                        }
4421                        GeneratedField::OrderBy => {
4422                            if order_by__.is_some() {
4423                                return Err(serde::de::Error::duplicate_field("orderBy"));
4424                            }
4425                            order_by__ = Some(map_.next_value()?);
4426                        }
4427                        GeneratedField::StateTable => {
4428                            if state_table__.is_some() {
4429                                return Err(serde::de::Error::duplicate_field("stateTable"));
4430                            }
4431                            state_table__ = map_.next_value()?;
4432                        }
4433                    }
4434                }
4435                Ok(EowcOverWindowNode {
4436                    calls: calls__.unwrap_or_default(),
4437                    partition_by: partition_by__.unwrap_or_default(),
4438                    order_by: order_by__.unwrap_or_default(),
4439                    state_table: state_table__,
4440                })
4441            }
4442        }
4443        deserializer.deserialize_struct("stream_plan.EowcOverWindowNode", FIELDS, GeneratedVisitor)
4444    }
4445}
4446impl serde::Serialize for ExchangeNode {
4447    #[allow(deprecated)]
4448    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4449    where
4450        S: serde::Serializer,
4451    {
4452        use serde::ser::SerializeStruct;
4453        let mut len = 0;
4454        if self.strategy.is_some() {
4455            len += 1;
4456        }
4457        let mut struct_ser = serializer.serialize_struct("stream_plan.ExchangeNode", len)?;
4458        if let Some(v) = self.strategy.as_ref() {
4459            struct_ser.serialize_field("strategy", v)?;
4460        }
4461        struct_ser.end()
4462    }
4463}
4464impl<'de> serde::Deserialize<'de> for ExchangeNode {
4465    #[allow(deprecated)]
4466    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4467    where
4468        D: serde::Deserializer<'de>,
4469    {
4470        const FIELDS: &[&str] = &[
4471            "strategy",
4472        ];
4473
4474        #[allow(clippy::enum_variant_names)]
4475        enum GeneratedField {
4476            Strategy,
4477        }
4478        impl<'de> serde::Deserialize<'de> for GeneratedField {
4479            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4480            where
4481                D: serde::Deserializer<'de>,
4482            {
4483                struct GeneratedVisitor;
4484
4485                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4486                    type Value = GeneratedField;
4487
4488                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4489                        write!(formatter, "expected one of: {:?}", &FIELDS)
4490                    }
4491
4492                    #[allow(unused_variables)]
4493                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4494                    where
4495                        E: serde::de::Error,
4496                    {
4497                        match value {
4498                            "strategy" => Ok(GeneratedField::Strategy),
4499                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4500                        }
4501                    }
4502                }
4503                deserializer.deserialize_identifier(GeneratedVisitor)
4504            }
4505        }
4506        struct GeneratedVisitor;
4507        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4508            type Value = ExchangeNode;
4509
4510            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4511                formatter.write_str("struct stream_plan.ExchangeNode")
4512            }
4513
4514            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExchangeNode, V::Error>
4515                where
4516                    V: serde::de::MapAccess<'de>,
4517            {
4518                let mut strategy__ = None;
4519                while let Some(k) = map_.next_key()? {
4520                    match k {
4521                        GeneratedField::Strategy => {
4522                            if strategy__.is_some() {
4523                                return Err(serde::de::Error::duplicate_field("strategy"));
4524                            }
4525                            strategy__ = map_.next_value()?;
4526                        }
4527                    }
4528                }
4529                Ok(ExchangeNode {
4530                    strategy: strategy__,
4531                })
4532            }
4533        }
4534        deserializer.deserialize_struct("stream_plan.ExchangeNode", FIELDS, GeneratedVisitor)
4535    }
4536}
4537impl serde::Serialize for ExpandNode {
4538    #[allow(deprecated)]
4539    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4540    where
4541        S: serde::Serializer,
4542    {
4543        use serde::ser::SerializeStruct;
4544        let mut len = 0;
4545        if !self.column_subsets.is_empty() {
4546            len += 1;
4547        }
4548        let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode", len)?;
4549        if !self.column_subsets.is_empty() {
4550            struct_ser.serialize_field("columnSubsets", &self.column_subsets)?;
4551        }
4552        struct_ser.end()
4553    }
4554}
4555impl<'de> serde::Deserialize<'de> for ExpandNode {
4556    #[allow(deprecated)]
4557    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4558    where
4559        D: serde::Deserializer<'de>,
4560    {
4561        const FIELDS: &[&str] = &[
4562            "column_subsets",
4563            "columnSubsets",
4564        ];
4565
4566        #[allow(clippy::enum_variant_names)]
4567        enum GeneratedField {
4568            ColumnSubsets,
4569        }
4570        impl<'de> serde::Deserialize<'de> for GeneratedField {
4571            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4572            where
4573                D: serde::Deserializer<'de>,
4574            {
4575                struct GeneratedVisitor;
4576
4577                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4578                    type Value = GeneratedField;
4579
4580                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4581                        write!(formatter, "expected one of: {:?}", &FIELDS)
4582                    }
4583
4584                    #[allow(unused_variables)]
4585                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4586                    where
4587                        E: serde::de::Error,
4588                    {
4589                        match value {
4590                            "columnSubsets" | "column_subsets" => Ok(GeneratedField::ColumnSubsets),
4591                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4592                        }
4593                    }
4594                }
4595                deserializer.deserialize_identifier(GeneratedVisitor)
4596            }
4597        }
4598        struct GeneratedVisitor;
4599        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4600            type Value = ExpandNode;
4601
4602            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4603                formatter.write_str("struct stream_plan.ExpandNode")
4604            }
4605
4606            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ExpandNode, V::Error>
4607                where
4608                    V: serde::de::MapAccess<'de>,
4609            {
4610                let mut column_subsets__ = None;
4611                while let Some(k) = map_.next_key()? {
4612                    match k {
4613                        GeneratedField::ColumnSubsets => {
4614                            if column_subsets__.is_some() {
4615                                return Err(serde::de::Error::duplicate_field("columnSubsets"));
4616                            }
4617                            column_subsets__ = Some(map_.next_value()?);
4618                        }
4619                    }
4620                }
4621                Ok(ExpandNode {
4622                    column_subsets: column_subsets__.unwrap_or_default(),
4623                })
4624            }
4625        }
4626        deserializer.deserialize_struct("stream_plan.ExpandNode", FIELDS, GeneratedVisitor)
4627    }
4628}
4629impl serde::Serialize for expand_node::Subset {
4630    #[allow(deprecated)]
4631    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4632    where
4633        S: serde::Serializer,
4634    {
4635        use serde::ser::SerializeStruct;
4636        let mut len = 0;
4637        if !self.column_indices.is_empty() {
4638            len += 1;
4639        }
4640        let mut struct_ser = serializer.serialize_struct("stream_plan.ExpandNode.Subset", len)?;
4641        if !self.column_indices.is_empty() {
4642            struct_ser.serialize_field("columnIndices", &self.column_indices)?;
4643        }
4644        struct_ser.end()
4645    }
4646}
4647impl<'de> serde::Deserialize<'de> for expand_node::Subset {
4648    #[allow(deprecated)]
4649    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4650    where
4651        D: serde::Deserializer<'de>,
4652    {
4653        const FIELDS: &[&str] = &[
4654            "column_indices",
4655            "columnIndices",
4656        ];
4657
4658        #[allow(clippy::enum_variant_names)]
4659        enum GeneratedField {
4660            ColumnIndices,
4661        }
4662        impl<'de> serde::Deserialize<'de> for GeneratedField {
4663            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4664            where
4665                D: serde::Deserializer<'de>,
4666            {
4667                struct GeneratedVisitor;
4668
4669                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4670                    type Value = GeneratedField;
4671
4672                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4673                        write!(formatter, "expected one of: {:?}", &FIELDS)
4674                    }
4675
4676                    #[allow(unused_variables)]
4677                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4678                    where
4679                        E: serde::de::Error,
4680                    {
4681                        match value {
4682                            "columnIndices" | "column_indices" => Ok(GeneratedField::ColumnIndices),
4683                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4684                        }
4685                    }
4686                }
4687                deserializer.deserialize_identifier(GeneratedVisitor)
4688            }
4689        }
4690        struct GeneratedVisitor;
4691        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4692            type Value = expand_node::Subset;
4693
4694            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4695                formatter.write_str("struct stream_plan.ExpandNode.Subset")
4696            }
4697
4698            fn visit_map<V>(self, mut map_: V) -> std::result::Result<expand_node::Subset, V::Error>
4699                where
4700                    V: serde::de::MapAccess<'de>,
4701            {
4702                let mut column_indices__ = None;
4703                while let Some(k) = map_.next_key()? {
4704                    match k {
4705                        GeneratedField::ColumnIndices => {
4706                            if column_indices__.is_some() {
4707                                return Err(serde::de::Error::duplicate_field("columnIndices"));
4708                            }
4709                            column_indices__ = 
4710                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
4711                                    .into_iter().map(|x| x.0).collect())
4712                            ;
4713                        }
4714                    }
4715                }
4716                Ok(expand_node::Subset {
4717                    column_indices: column_indices__.unwrap_or_default(),
4718                })
4719            }
4720        }
4721        deserializer.deserialize_struct("stream_plan.ExpandNode.Subset", FIELDS, GeneratedVisitor)
4722    }
4723}
4724impl serde::Serialize for FilterNode {
4725    #[allow(deprecated)]
4726    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4727    where
4728        S: serde::Serializer,
4729    {
4730        use serde::ser::SerializeStruct;
4731        let mut len = 0;
4732        if self.search_condition.is_some() {
4733            len += 1;
4734        }
4735        let mut struct_ser = serializer.serialize_struct("stream_plan.FilterNode", len)?;
4736        if let Some(v) = self.search_condition.as_ref() {
4737            struct_ser.serialize_field("searchCondition", v)?;
4738        }
4739        struct_ser.end()
4740    }
4741}
4742impl<'de> serde::Deserialize<'de> for FilterNode {
4743    #[allow(deprecated)]
4744    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4745    where
4746        D: serde::Deserializer<'de>,
4747    {
4748        const FIELDS: &[&str] = &[
4749            "search_condition",
4750            "searchCondition",
4751        ];
4752
4753        #[allow(clippy::enum_variant_names)]
4754        enum GeneratedField {
4755            SearchCondition,
4756        }
4757        impl<'de> serde::Deserialize<'de> for GeneratedField {
4758            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4759            where
4760                D: serde::Deserializer<'de>,
4761            {
4762                struct GeneratedVisitor;
4763
4764                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4765                    type Value = GeneratedField;
4766
4767                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4768                        write!(formatter, "expected one of: {:?}", &FIELDS)
4769                    }
4770
4771                    #[allow(unused_variables)]
4772                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4773                    where
4774                        E: serde::de::Error,
4775                    {
4776                        match value {
4777                            "searchCondition" | "search_condition" => Ok(GeneratedField::SearchCondition),
4778                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4779                        }
4780                    }
4781                }
4782                deserializer.deserialize_identifier(GeneratedVisitor)
4783            }
4784        }
4785        struct GeneratedVisitor;
4786        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4787            type Value = FilterNode;
4788
4789            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4790                formatter.write_str("struct stream_plan.FilterNode")
4791            }
4792
4793            fn visit_map<V>(self, mut map_: V) -> std::result::Result<FilterNode, V::Error>
4794                where
4795                    V: serde::de::MapAccess<'de>,
4796            {
4797                let mut search_condition__ = None;
4798                while let Some(k) = map_.next_key()? {
4799                    match k {
4800                        GeneratedField::SearchCondition => {
4801                            if search_condition__.is_some() {
4802                                return Err(serde::de::Error::duplicate_field("searchCondition"));
4803                            }
4804                            search_condition__ = map_.next_value()?;
4805                        }
4806                    }
4807                }
4808                Ok(FilterNode {
4809                    search_condition: search_condition__,
4810                })
4811            }
4812        }
4813        deserializer.deserialize_struct("stream_plan.FilterNode", FIELDS, GeneratedVisitor)
4814    }
4815}
4816impl serde::Serialize for GlobalApproxPercentileNode {
4817    #[allow(deprecated)]
4818    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4819    where
4820        S: serde::Serializer,
4821    {
4822        use serde::ser::SerializeStruct;
4823        let mut len = 0;
4824        if self.base != 0. {
4825            len += 1;
4826        }
4827        if self.quantile != 0. {
4828            len += 1;
4829        }
4830        if self.bucket_state_table.is_some() {
4831            len += 1;
4832        }
4833        if self.count_state_table.is_some() {
4834            len += 1;
4835        }
4836        let mut struct_ser = serializer.serialize_struct("stream_plan.GlobalApproxPercentileNode", len)?;
4837        if self.base != 0. {
4838            struct_ser.serialize_field("base", &self.base)?;
4839        }
4840        if self.quantile != 0. {
4841            struct_ser.serialize_field("quantile", &self.quantile)?;
4842        }
4843        if let Some(v) = self.bucket_state_table.as_ref() {
4844            struct_ser.serialize_field("bucketStateTable", v)?;
4845        }
4846        if let Some(v) = self.count_state_table.as_ref() {
4847            struct_ser.serialize_field("countStateTable", v)?;
4848        }
4849        struct_ser.end()
4850    }
4851}
4852impl<'de> serde::Deserialize<'de> for GlobalApproxPercentileNode {
4853    #[allow(deprecated)]
4854    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
4855    where
4856        D: serde::Deserializer<'de>,
4857    {
4858        const FIELDS: &[&str] = &[
4859            "base",
4860            "quantile",
4861            "bucket_state_table",
4862            "bucketStateTable",
4863            "count_state_table",
4864            "countStateTable",
4865        ];
4866
4867        #[allow(clippy::enum_variant_names)]
4868        enum GeneratedField {
4869            Base,
4870            Quantile,
4871            BucketStateTable,
4872            CountStateTable,
4873        }
4874        impl<'de> serde::Deserialize<'de> for GeneratedField {
4875            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
4876            where
4877                D: serde::Deserializer<'de>,
4878            {
4879                struct GeneratedVisitor;
4880
4881                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4882                    type Value = GeneratedField;
4883
4884                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4885                        write!(formatter, "expected one of: {:?}", &FIELDS)
4886                    }
4887
4888                    #[allow(unused_variables)]
4889                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
4890                    where
4891                        E: serde::de::Error,
4892                    {
4893                        match value {
4894                            "base" => Ok(GeneratedField::Base),
4895                            "quantile" => Ok(GeneratedField::Quantile),
4896                            "bucketStateTable" | "bucket_state_table" => Ok(GeneratedField::BucketStateTable),
4897                            "countStateTable" | "count_state_table" => Ok(GeneratedField::CountStateTable),
4898                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
4899                        }
4900                    }
4901                }
4902                deserializer.deserialize_identifier(GeneratedVisitor)
4903            }
4904        }
4905        struct GeneratedVisitor;
4906        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
4907            type Value = GlobalApproxPercentileNode;
4908
4909            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4910                formatter.write_str("struct stream_plan.GlobalApproxPercentileNode")
4911            }
4912
4913            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GlobalApproxPercentileNode, V::Error>
4914                where
4915                    V: serde::de::MapAccess<'de>,
4916            {
4917                let mut base__ = None;
4918                let mut quantile__ = None;
4919                let mut bucket_state_table__ = None;
4920                let mut count_state_table__ = None;
4921                while let Some(k) = map_.next_key()? {
4922                    match k {
4923                        GeneratedField::Base => {
4924                            if base__.is_some() {
4925                                return Err(serde::de::Error::duplicate_field("base"));
4926                            }
4927                            base__ = 
4928                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4929                            ;
4930                        }
4931                        GeneratedField::Quantile => {
4932                            if quantile__.is_some() {
4933                                return Err(serde::de::Error::duplicate_field("quantile"));
4934                            }
4935                            quantile__ = 
4936                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
4937                            ;
4938                        }
4939                        GeneratedField::BucketStateTable => {
4940                            if bucket_state_table__.is_some() {
4941                                return Err(serde::de::Error::duplicate_field("bucketStateTable"));
4942                            }
4943                            bucket_state_table__ = map_.next_value()?;
4944                        }
4945                        GeneratedField::CountStateTable => {
4946                            if count_state_table__.is_some() {
4947                                return Err(serde::de::Error::duplicate_field("countStateTable"));
4948                            }
4949                            count_state_table__ = map_.next_value()?;
4950                        }
4951                    }
4952                }
4953                Ok(GlobalApproxPercentileNode {
4954                    base: base__.unwrap_or_default(),
4955                    quantile: quantile__.unwrap_or_default(),
4956                    bucket_state_table: bucket_state_table__,
4957                    count_state_table: count_state_table__,
4958                })
4959            }
4960        }
4961        deserializer.deserialize_struct("stream_plan.GlobalApproxPercentileNode", FIELDS, GeneratedVisitor)
4962    }
4963}
4964impl serde::Serialize for GroupTopNNode {
4965    #[allow(deprecated)]
4966    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
4967    where
4968        S: serde::Serializer,
4969    {
4970        use serde::ser::SerializeStruct;
4971        let mut len = 0;
4972        if self.limit != 0 {
4973            len += 1;
4974        }
4975        if self.offset != 0 {
4976            len += 1;
4977        }
4978        if !self.group_key.is_empty() {
4979            len += 1;
4980        }
4981        if self.table.is_some() {
4982            len += 1;
4983        }
4984        if !self.order_by.is_empty() {
4985            len += 1;
4986        }
4987        if self.with_ties {
4988            len += 1;
4989        }
4990        let mut struct_ser = serializer.serialize_struct("stream_plan.GroupTopNNode", len)?;
4991        if self.limit != 0 {
4992            #[allow(clippy::needless_borrow)]
4993            #[allow(clippy::needless_borrows_for_generic_args)]
4994            struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
4995        }
4996        if self.offset != 0 {
4997            #[allow(clippy::needless_borrow)]
4998            #[allow(clippy::needless_borrows_for_generic_args)]
4999            struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
5000        }
5001        if !self.group_key.is_empty() {
5002            struct_ser.serialize_field("groupKey", &self.group_key)?;
5003        }
5004        if let Some(v) = self.table.as_ref() {
5005            struct_ser.serialize_field("table", v)?;
5006        }
5007        if !self.order_by.is_empty() {
5008            struct_ser.serialize_field("orderBy", &self.order_by)?;
5009        }
5010        if self.with_ties {
5011            struct_ser.serialize_field("withTies", &self.with_ties)?;
5012        }
5013        struct_ser.end()
5014    }
5015}
5016impl<'de> serde::Deserialize<'de> for GroupTopNNode {
5017    #[allow(deprecated)]
5018    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5019    where
5020        D: serde::Deserializer<'de>,
5021    {
5022        const FIELDS: &[&str] = &[
5023            "limit",
5024            "offset",
5025            "group_key",
5026            "groupKey",
5027            "table",
5028            "order_by",
5029            "orderBy",
5030            "with_ties",
5031            "withTies",
5032        ];
5033
5034        #[allow(clippy::enum_variant_names)]
5035        enum GeneratedField {
5036            Limit,
5037            Offset,
5038            GroupKey,
5039            Table,
5040            OrderBy,
5041            WithTies,
5042        }
5043        impl<'de> serde::Deserialize<'de> for GeneratedField {
5044            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5045            where
5046                D: serde::Deserializer<'de>,
5047            {
5048                struct GeneratedVisitor;
5049
5050                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5051                    type Value = GeneratedField;
5052
5053                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5054                        write!(formatter, "expected one of: {:?}", &FIELDS)
5055                    }
5056
5057                    #[allow(unused_variables)]
5058                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5059                    where
5060                        E: serde::de::Error,
5061                    {
5062                        match value {
5063                            "limit" => Ok(GeneratedField::Limit),
5064                            "offset" => Ok(GeneratedField::Offset),
5065                            "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5066                            "table" => Ok(GeneratedField::Table),
5067                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
5068                            "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
5069                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5070                        }
5071                    }
5072                }
5073                deserializer.deserialize_identifier(GeneratedVisitor)
5074            }
5075        }
5076        struct GeneratedVisitor;
5077        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5078            type Value = GroupTopNNode;
5079
5080            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5081                formatter.write_str("struct stream_plan.GroupTopNNode")
5082            }
5083
5084            fn visit_map<V>(self, mut map_: V) -> std::result::Result<GroupTopNNode, V::Error>
5085                where
5086                    V: serde::de::MapAccess<'de>,
5087            {
5088                let mut limit__ = None;
5089                let mut offset__ = None;
5090                let mut group_key__ = None;
5091                let mut table__ = None;
5092                let mut order_by__ = None;
5093                let mut with_ties__ = None;
5094                while let Some(k) = map_.next_key()? {
5095                    match k {
5096                        GeneratedField::Limit => {
5097                            if limit__.is_some() {
5098                                return Err(serde::de::Error::duplicate_field("limit"));
5099                            }
5100                            limit__ = 
5101                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5102                            ;
5103                        }
5104                        GeneratedField::Offset => {
5105                            if offset__.is_some() {
5106                                return Err(serde::de::Error::duplicate_field("offset"));
5107                            }
5108                            offset__ = 
5109                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5110                            ;
5111                        }
5112                        GeneratedField::GroupKey => {
5113                            if group_key__.is_some() {
5114                                return Err(serde::de::Error::duplicate_field("groupKey"));
5115                            }
5116                            group_key__ = 
5117                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5118                                    .into_iter().map(|x| x.0).collect())
5119                            ;
5120                        }
5121                        GeneratedField::Table => {
5122                            if table__.is_some() {
5123                                return Err(serde::de::Error::duplicate_field("table"));
5124                            }
5125                            table__ = map_.next_value()?;
5126                        }
5127                        GeneratedField::OrderBy => {
5128                            if order_by__.is_some() {
5129                                return Err(serde::de::Error::duplicate_field("orderBy"));
5130                            }
5131                            order_by__ = Some(map_.next_value()?);
5132                        }
5133                        GeneratedField::WithTies => {
5134                            if with_ties__.is_some() {
5135                                return Err(serde::de::Error::duplicate_field("withTies"));
5136                            }
5137                            with_ties__ = Some(map_.next_value()?);
5138                        }
5139                    }
5140                }
5141                Ok(GroupTopNNode {
5142                    limit: limit__.unwrap_or_default(),
5143                    offset: offset__.unwrap_or_default(),
5144                    group_key: group_key__.unwrap_or_default(),
5145                    table: table__,
5146                    order_by: order_by__.unwrap_or_default(),
5147                    with_ties: with_ties__.unwrap_or_default(),
5148                })
5149            }
5150        }
5151        deserializer.deserialize_struct("stream_plan.GroupTopNNode", FIELDS, GeneratedVisitor)
5152    }
5153}
5154impl serde::Serialize for HashAggNode {
5155    #[allow(deprecated)]
5156    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5157    where
5158        S: serde::Serializer,
5159    {
5160        use serde::ser::SerializeStruct;
5161        let mut len = 0;
5162        if !self.group_key.is_empty() {
5163            len += 1;
5164        }
5165        if !self.agg_calls.is_empty() {
5166            len += 1;
5167        }
5168        if !self.agg_call_states.is_empty() {
5169            len += 1;
5170        }
5171        if self.intermediate_state_table.is_some() {
5172            len += 1;
5173        }
5174        if self.is_append_only {
5175            len += 1;
5176        }
5177        if !self.distinct_dedup_tables.is_empty() {
5178            len += 1;
5179        }
5180        if self.row_count_index != 0 {
5181            len += 1;
5182        }
5183        if self.emit_on_window_close {
5184            len += 1;
5185        }
5186        if self.version != 0 {
5187            len += 1;
5188        }
5189        let mut struct_ser = serializer.serialize_struct("stream_plan.HashAggNode", len)?;
5190        if !self.group_key.is_empty() {
5191            struct_ser.serialize_field("groupKey", &self.group_key)?;
5192        }
5193        if !self.agg_calls.is_empty() {
5194            struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
5195        }
5196        if !self.agg_call_states.is_empty() {
5197            struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
5198        }
5199        if let Some(v) = self.intermediate_state_table.as_ref() {
5200            struct_ser.serialize_field("intermediateStateTable", v)?;
5201        }
5202        if self.is_append_only {
5203            struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5204        }
5205        if !self.distinct_dedup_tables.is_empty() {
5206            struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
5207        }
5208        if self.row_count_index != 0 {
5209            struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
5210        }
5211        if self.emit_on_window_close {
5212            struct_ser.serialize_field("emitOnWindowClose", &self.emit_on_window_close)?;
5213        }
5214        if self.version != 0 {
5215            let v = AggNodeVersion::try_from(self.version)
5216                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
5217            struct_ser.serialize_field("version", &v)?;
5218        }
5219        struct_ser.end()
5220    }
5221}
5222impl<'de> serde::Deserialize<'de> for HashAggNode {
5223    #[allow(deprecated)]
5224    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5225    where
5226        D: serde::Deserializer<'de>,
5227    {
5228        const FIELDS: &[&str] = &[
5229            "group_key",
5230            "groupKey",
5231            "agg_calls",
5232            "aggCalls",
5233            "agg_call_states",
5234            "aggCallStates",
5235            "intermediate_state_table",
5236            "intermediateStateTable",
5237            "is_append_only",
5238            "isAppendOnly",
5239            "distinct_dedup_tables",
5240            "distinctDedupTables",
5241            "row_count_index",
5242            "rowCountIndex",
5243            "emit_on_window_close",
5244            "emitOnWindowClose",
5245            "version",
5246        ];
5247
5248        #[allow(clippy::enum_variant_names)]
5249        enum GeneratedField {
5250            GroupKey,
5251            AggCalls,
5252            AggCallStates,
5253            IntermediateStateTable,
5254            IsAppendOnly,
5255            DistinctDedupTables,
5256            RowCountIndex,
5257            EmitOnWindowClose,
5258            Version,
5259        }
5260        impl<'de> serde::Deserialize<'de> for GeneratedField {
5261            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5262            where
5263                D: serde::Deserializer<'de>,
5264            {
5265                struct GeneratedVisitor;
5266
5267                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5268                    type Value = GeneratedField;
5269
5270                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5271                        write!(formatter, "expected one of: {:?}", &FIELDS)
5272                    }
5273
5274                    #[allow(unused_variables)]
5275                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5276                    where
5277                        E: serde::de::Error,
5278                    {
5279                        match value {
5280                            "groupKey" | "group_key" => Ok(GeneratedField::GroupKey),
5281                            "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
5282                            "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
5283                            "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
5284                            "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5285                            "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
5286                            "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
5287                            "emitOnWindowClose" | "emit_on_window_close" => Ok(GeneratedField::EmitOnWindowClose),
5288                            "version" => Ok(GeneratedField::Version),
5289                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5290                        }
5291                    }
5292                }
5293                deserializer.deserialize_identifier(GeneratedVisitor)
5294            }
5295        }
5296        struct GeneratedVisitor;
5297        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5298            type Value = HashAggNode;
5299
5300            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5301                formatter.write_str("struct stream_plan.HashAggNode")
5302            }
5303
5304            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashAggNode, V::Error>
5305                where
5306                    V: serde::de::MapAccess<'de>,
5307            {
5308                let mut group_key__ = None;
5309                let mut agg_calls__ = None;
5310                let mut agg_call_states__ = None;
5311                let mut intermediate_state_table__ = None;
5312                let mut is_append_only__ = None;
5313                let mut distinct_dedup_tables__ = None;
5314                let mut row_count_index__ = None;
5315                let mut emit_on_window_close__ = None;
5316                let mut version__ = None;
5317                while let Some(k) = map_.next_key()? {
5318                    match k {
5319                        GeneratedField::GroupKey => {
5320                            if group_key__.is_some() {
5321                                return Err(serde::de::Error::duplicate_field("groupKey"));
5322                            }
5323                            group_key__ = 
5324                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5325                                    .into_iter().map(|x| x.0).collect())
5326                            ;
5327                        }
5328                        GeneratedField::AggCalls => {
5329                            if agg_calls__.is_some() {
5330                                return Err(serde::de::Error::duplicate_field("aggCalls"));
5331                            }
5332                            agg_calls__ = Some(map_.next_value()?);
5333                        }
5334                        GeneratedField::AggCallStates => {
5335                            if agg_call_states__.is_some() {
5336                                return Err(serde::de::Error::duplicate_field("aggCallStates"));
5337                            }
5338                            agg_call_states__ = Some(map_.next_value()?);
5339                        }
5340                        GeneratedField::IntermediateStateTable => {
5341                            if intermediate_state_table__.is_some() {
5342                                return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
5343                            }
5344                            intermediate_state_table__ = map_.next_value()?;
5345                        }
5346                        GeneratedField::IsAppendOnly => {
5347                            if is_append_only__.is_some() {
5348                                return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5349                            }
5350                            is_append_only__ = Some(map_.next_value()?);
5351                        }
5352                        GeneratedField::DistinctDedupTables => {
5353                            if distinct_dedup_tables__.is_some() {
5354                                return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
5355                            }
5356                            distinct_dedup_tables__ = Some(
5357                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
5358                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
5359                            );
5360                        }
5361                        GeneratedField::RowCountIndex => {
5362                            if row_count_index__.is_some() {
5363                                return Err(serde::de::Error::duplicate_field("rowCountIndex"));
5364                            }
5365                            row_count_index__ = 
5366                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5367                            ;
5368                        }
5369                        GeneratedField::EmitOnWindowClose => {
5370                            if emit_on_window_close__.is_some() {
5371                                return Err(serde::de::Error::duplicate_field("emitOnWindowClose"));
5372                            }
5373                            emit_on_window_close__ = Some(map_.next_value()?);
5374                        }
5375                        GeneratedField::Version => {
5376                            if version__.is_some() {
5377                                return Err(serde::de::Error::duplicate_field("version"));
5378                            }
5379                            version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
5380                        }
5381                    }
5382                }
5383                Ok(HashAggNode {
5384                    group_key: group_key__.unwrap_or_default(),
5385                    agg_calls: agg_calls__.unwrap_or_default(),
5386                    agg_call_states: agg_call_states__.unwrap_or_default(),
5387                    intermediate_state_table: intermediate_state_table__,
5388                    is_append_only: is_append_only__.unwrap_or_default(),
5389                    distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
5390                    row_count_index: row_count_index__.unwrap_or_default(),
5391                    emit_on_window_close: emit_on_window_close__.unwrap_or_default(),
5392                    version: version__.unwrap_or_default(),
5393                })
5394            }
5395        }
5396        deserializer.deserialize_struct("stream_plan.HashAggNode", FIELDS, GeneratedVisitor)
5397    }
5398}
5399impl serde::Serialize for HashJoinNode {
5400    #[allow(deprecated)]
5401    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5402    where
5403        S: serde::Serializer,
5404    {
5405        use serde::ser::SerializeStruct;
5406        let mut len = 0;
5407        if self.join_type != 0 {
5408            len += 1;
5409        }
5410        if !self.left_key.is_empty() {
5411            len += 1;
5412        }
5413        if !self.right_key.is_empty() {
5414            len += 1;
5415        }
5416        if self.condition.is_some() {
5417            len += 1;
5418        }
5419        if !self.inequality_pairs.is_empty() {
5420            len += 1;
5421        }
5422        if self.left_table.is_some() {
5423            len += 1;
5424        }
5425        if self.right_table.is_some() {
5426            len += 1;
5427        }
5428        if self.left_degree_table.is_some() {
5429            len += 1;
5430        }
5431        if self.right_degree_table.is_some() {
5432            len += 1;
5433        }
5434        if !self.output_indices.is_empty() {
5435            len += 1;
5436        }
5437        if !self.left_deduped_input_pk_indices.is_empty() {
5438            len += 1;
5439        }
5440        if !self.right_deduped_input_pk_indices.is_empty() {
5441            len += 1;
5442        }
5443        if !self.null_safe.is_empty() {
5444            len += 1;
5445        }
5446        if self.is_append_only {
5447            len += 1;
5448        }
5449        if self.join_encoding_type != 0 {
5450            len += 1;
5451        }
5452        let mut struct_ser = serializer.serialize_struct("stream_plan.HashJoinNode", len)?;
5453        if self.join_type != 0 {
5454            let v = super::plan_common::JoinType::try_from(self.join_type)
5455                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
5456            struct_ser.serialize_field("joinType", &v)?;
5457        }
5458        if !self.left_key.is_empty() {
5459            struct_ser.serialize_field("leftKey", &self.left_key)?;
5460        }
5461        if !self.right_key.is_empty() {
5462            struct_ser.serialize_field("rightKey", &self.right_key)?;
5463        }
5464        if let Some(v) = self.condition.as_ref() {
5465            struct_ser.serialize_field("condition", v)?;
5466        }
5467        if !self.inequality_pairs.is_empty() {
5468            struct_ser.serialize_field("inequalityPairs", &self.inequality_pairs)?;
5469        }
5470        if let Some(v) = self.left_table.as_ref() {
5471            struct_ser.serialize_field("leftTable", v)?;
5472        }
5473        if let Some(v) = self.right_table.as_ref() {
5474            struct_ser.serialize_field("rightTable", v)?;
5475        }
5476        if let Some(v) = self.left_degree_table.as_ref() {
5477            struct_ser.serialize_field("leftDegreeTable", v)?;
5478        }
5479        if let Some(v) = self.right_degree_table.as_ref() {
5480            struct_ser.serialize_field("rightDegreeTable", v)?;
5481        }
5482        if !self.output_indices.is_empty() {
5483            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5484        }
5485        if !self.left_deduped_input_pk_indices.is_empty() {
5486            struct_ser.serialize_field("leftDedupedInputPkIndices", &self.left_deduped_input_pk_indices)?;
5487        }
5488        if !self.right_deduped_input_pk_indices.is_empty() {
5489            struct_ser.serialize_field("rightDedupedInputPkIndices", &self.right_deduped_input_pk_indices)?;
5490        }
5491        if !self.null_safe.is_empty() {
5492            struct_ser.serialize_field("nullSafe", &self.null_safe)?;
5493        }
5494        if self.is_append_only {
5495            struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
5496        }
5497        if self.join_encoding_type != 0 {
5498            let v = JoinEncodingType::try_from(self.join_encoding_type)
5499                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_encoding_type)))?;
5500            struct_ser.serialize_field("joinEncodingType", &v)?;
5501        }
5502        struct_ser.end()
5503    }
5504}
5505impl<'de> serde::Deserialize<'de> for HashJoinNode {
5506    #[allow(deprecated)]
5507    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5508    where
5509        D: serde::Deserializer<'de>,
5510    {
5511        const FIELDS: &[&str] = &[
5512            "join_type",
5513            "joinType",
5514            "left_key",
5515            "leftKey",
5516            "right_key",
5517            "rightKey",
5518            "condition",
5519            "inequality_pairs",
5520            "inequalityPairs",
5521            "left_table",
5522            "leftTable",
5523            "right_table",
5524            "rightTable",
5525            "left_degree_table",
5526            "leftDegreeTable",
5527            "right_degree_table",
5528            "rightDegreeTable",
5529            "output_indices",
5530            "outputIndices",
5531            "left_deduped_input_pk_indices",
5532            "leftDedupedInputPkIndices",
5533            "right_deduped_input_pk_indices",
5534            "rightDedupedInputPkIndices",
5535            "null_safe",
5536            "nullSafe",
5537            "is_append_only",
5538            "isAppendOnly",
5539            "join_encoding_type",
5540            "joinEncodingType",
5541        ];
5542
5543        #[allow(clippy::enum_variant_names)]
5544        enum GeneratedField {
5545            JoinType,
5546            LeftKey,
5547            RightKey,
5548            Condition,
5549            InequalityPairs,
5550            LeftTable,
5551            RightTable,
5552            LeftDegreeTable,
5553            RightDegreeTable,
5554            OutputIndices,
5555            LeftDedupedInputPkIndices,
5556            RightDedupedInputPkIndices,
5557            NullSafe,
5558            IsAppendOnly,
5559            JoinEncodingType,
5560        }
5561        impl<'de> serde::Deserialize<'de> for GeneratedField {
5562            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5563            where
5564                D: serde::Deserializer<'de>,
5565            {
5566                struct GeneratedVisitor;
5567
5568                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5569                    type Value = GeneratedField;
5570
5571                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5572                        write!(formatter, "expected one of: {:?}", &FIELDS)
5573                    }
5574
5575                    #[allow(unused_variables)]
5576                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5577                    where
5578                        E: serde::de::Error,
5579                    {
5580                        match value {
5581                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
5582                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
5583                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
5584                            "condition" => Ok(GeneratedField::Condition),
5585                            "inequalityPairs" | "inequality_pairs" => Ok(GeneratedField::InequalityPairs),
5586                            "leftTable" | "left_table" => Ok(GeneratedField::LeftTable),
5587                            "rightTable" | "right_table" => Ok(GeneratedField::RightTable),
5588                            "leftDegreeTable" | "left_degree_table" => Ok(GeneratedField::LeftDegreeTable),
5589                            "rightDegreeTable" | "right_degree_table" => Ok(GeneratedField::RightDegreeTable),
5590                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5591                            "leftDedupedInputPkIndices" | "left_deduped_input_pk_indices" => Ok(GeneratedField::LeftDedupedInputPkIndices),
5592                            "rightDedupedInputPkIndices" | "right_deduped_input_pk_indices" => Ok(GeneratedField::RightDedupedInputPkIndices),
5593                            "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
5594                            "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
5595                            "joinEncodingType" | "join_encoding_type" => Ok(GeneratedField::JoinEncodingType),
5596                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5597                        }
5598                    }
5599                }
5600                deserializer.deserialize_identifier(GeneratedVisitor)
5601            }
5602        }
5603        struct GeneratedVisitor;
5604        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5605            type Value = HashJoinNode;
5606
5607            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5608                formatter.write_str("struct stream_plan.HashJoinNode")
5609            }
5610
5611            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HashJoinNode, V::Error>
5612                where
5613                    V: serde::de::MapAccess<'de>,
5614            {
5615                let mut join_type__ = None;
5616                let mut left_key__ = None;
5617                let mut right_key__ = None;
5618                let mut condition__ = None;
5619                let mut inequality_pairs__ = None;
5620                let mut left_table__ = None;
5621                let mut right_table__ = None;
5622                let mut left_degree_table__ = None;
5623                let mut right_degree_table__ = None;
5624                let mut output_indices__ = None;
5625                let mut left_deduped_input_pk_indices__ = None;
5626                let mut right_deduped_input_pk_indices__ = None;
5627                let mut null_safe__ = None;
5628                let mut is_append_only__ = None;
5629                let mut join_encoding_type__ = None;
5630                while let Some(k) = map_.next_key()? {
5631                    match k {
5632                        GeneratedField::JoinType => {
5633                            if join_type__.is_some() {
5634                                return Err(serde::de::Error::duplicate_field("joinType"));
5635                            }
5636                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
5637                        }
5638                        GeneratedField::LeftKey => {
5639                            if left_key__.is_some() {
5640                                return Err(serde::de::Error::duplicate_field("leftKey"));
5641                            }
5642                            left_key__ = 
5643                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5644                                    .into_iter().map(|x| x.0).collect())
5645                            ;
5646                        }
5647                        GeneratedField::RightKey => {
5648                            if right_key__.is_some() {
5649                                return Err(serde::de::Error::duplicate_field("rightKey"));
5650                            }
5651                            right_key__ = 
5652                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5653                                    .into_iter().map(|x| x.0).collect())
5654                            ;
5655                        }
5656                        GeneratedField::Condition => {
5657                            if condition__.is_some() {
5658                                return Err(serde::de::Error::duplicate_field("condition"));
5659                            }
5660                            condition__ = map_.next_value()?;
5661                        }
5662                        GeneratedField::InequalityPairs => {
5663                            if inequality_pairs__.is_some() {
5664                                return Err(serde::de::Error::duplicate_field("inequalityPairs"));
5665                            }
5666                            inequality_pairs__ = Some(map_.next_value()?);
5667                        }
5668                        GeneratedField::LeftTable => {
5669                            if left_table__.is_some() {
5670                                return Err(serde::de::Error::duplicate_field("leftTable"));
5671                            }
5672                            left_table__ = map_.next_value()?;
5673                        }
5674                        GeneratedField::RightTable => {
5675                            if right_table__.is_some() {
5676                                return Err(serde::de::Error::duplicate_field("rightTable"));
5677                            }
5678                            right_table__ = map_.next_value()?;
5679                        }
5680                        GeneratedField::LeftDegreeTable => {
5681                            if left_degree_table__.is_some() {
5682                                return Err(serde::de::Error::duplicate_field("leftDegreeTable"));
5683                            }
5684                            left_degree_table__ = map_.next_value()?;
5685                        }
5686                        GeneratedField::RightDegreeTable => {
5687                            if right_degree_table__.is_some() {
5688                                return Err(serde::de::Error::duplicate_field("rightDegreeTable"));
5689                            }
5690                            right_degree_table__ = map_.next_value()?;
5691                        }
5692                        GeneratedField::OutputIndices => {
5693                            if output_indices__.is_some() {
5694                                return Err(serde::de::Error::duplicate_field("outputIndices"));
5695                            }
5696                            output_indices__ = 
5697                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5698                                    .into_iter().map(|x| x.0).collect())
5699                            ;
5700                        }
5701                        GeneratedField::LeftDedupedInputPkIndices => {
5702                            if left_deduped_input_pk_indices__.is_some() {
5703                                return Err(serde::de::Error::duplicate_field("leftDedupedInputPkIndices"));
5704                            }
5705                            left_deduped_input_pk_indices__ = 
5706                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5707                                    .into_iter().map(|x| x.0).collect())
5708                            ;
5709                        }
5710                        GeneratedField::RightDedupedInputPkIndices => {
5711                            if right_deduped_input_pk_indices__.is_some() {
5712                                return Err(serde::de::Error::duplicate_field("rightDedupedInputPkIndices"));
5713                            }
5714                            right_deduped_input_pk_indices__ = 
5715                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5716                                    .into_iter().map(|x| x.0).collect())
5717                            ;
5718                        }
5719                        GeneratedField::NullSafe => {
5720                            if null_safe__.is_some() {
5721                                return Err(serde::de::Error::duplicate_field("nullSafe"));
5722                            }
5723                            null_safe__ = Some(map_.next_value()?);
5724                        }
5725                        GeneratedField::IsAppendOnly => {
5726                            if is_append_only__.is_some() {
5727                                return Err(serde::de::Error::duplicate_field("isAppendOnly"));
5728                            }
5729                            is_append_only__ = Some(map_.next_value()?);
5730                        }
5731                        GeneratedField::JoinEncodingType => {
5732                            if join_encoding_type__.is_some() {
5733                                return Err(serde::de::Error::duplicate_field("joinEncodingType"));
5734                            }
5735                            join_encoding_type__ = Some(map_.next_value::<JoinEncodingType>()? as i32);
5736                        }
5737                    }
5738                }
5739                Ok(HashJoinNode {
5740                    join_type: join_type__.unwrap_or_default(),
5741                    left_key: left_key__.unwrap_or_default(),
5742                    right_key: right_key__.unwrap_or_default(),
5743                    condition: condition__,
5744                    inequality_pairs: inequality_pairs__.unwrap_or_default(),
5745                    left_table: left_table__,
5746                    right_table: right_table__,
5747                    left_degree_table: left_degree_table__,
5748                    right_degree_table: right_degree_table__,
5749                    output_indices: output_indices__.unwrap_or_default(),
5750                    left_deduped_input_pk_indices: left_deduped_input_pk_indices__.unwrap_or_default(),
5751                    right_deduped_input_pk_indices: right_deduped_input_pk_indices__.unwrap_or_default(),
5752                    null_safe: null_safe__.unwrap_or_default(),
5753                    is_append_only: is_append_only__.unwrap_or_default(),
5754                    join_encoding_type: join_encoding_type__.unwrap_or_default(),
5755                })
5756            }
5757        }
5758        deserializer.deserialize_struct("stream_plan.HashJoinNode", FIELDS, GeneratedVisitor)
5759    }
5760}
5761impl serde::Serialize for HopWindowNode {
5762    #[allow(deprecated)]
5763    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5764    where
5765        S: serde::Serializer,
5766    {
5767        use serde::ser::SerializeStruct;
5768        let mut len = 0;
5769        if self.time_col != 0 {
5770            len += 1;
5771        }
5772        if self.window_slide.is_some() {
5773            len += 1;
5774        }
5775        if self.window_size.is_some() {
5776            len += 1;
5777        }
5778        if !self.output_indices.is_empty() {
5779            len += 1;
5780        }
5781        if !self.window_start_exprs.is_empty() {
5782            len += 1;
5783        }
5784        if !self.window_end_exprs.is_empty() {
5785            len += 1;
5786        }
5787        let mut struct_ser = serializer.serialize_struct("stream_plan.HopWindowNode", len)?;
5788        if self.time_col != 0 {
5789            struct_ser.serialize_field("timeCol", &self.time_col)?;
5790        }
5791        if let Some(v) = self.window_slide.as_ref() {
5792            struct_ser.serialize_field("windowSlide", v)?;
5793        }
5794        if let Some(v) = self.window_size.as_ref() {
5795            struct_ser.serialize_field("windowSize", v)?;
5796        }
5797        if !self.output_indices.is_empty() {
5798            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
5799        }
5800        if !self.window_start_exprs.is_empty() {
5801            struct_ser.serialize_field("windowStartExprs", &self.window_start_exprs)?;
5802        }
5803        if !self.window_end_exprs.is_empty() {
5804            struct_ser.serialize_field("windowEndExprs", &self.window_end_exprs)?;
5805        }
5806        struct_ser.end()
5807    }
5808}
5809impl<'de> serde::Deserialize<'de> for HopWindowNode {
5810    #[allow(deprecated)]
5811    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5812    where
5813        D: serde::Deserializer<'de>,
5814    {
5815        const FIELDS: &[&str] = &[
5816            "time_col",
5817            "timeCol",
5818            "window_slide",
5819            "windowSlide",
5820            "window_size",
5821            "windowSize",
5822            "output_indices",
5823            "outputIndices",
5824            "window_start_exprs",
5825            "windowStartExprs",
5826            "window_end_exprs",
5827            "windowEndExprs",
5828        ];
5829
5830        #[allow(clippy::enum_variant_names)]
5831        enum GeneratedField {
5832            TimeCol,
5833            WindowSlide,
5834            WindowSize,
5835            OutputIndices,
5836            WindowStartExprs,
5837            WindowEndExprs,
5838        }
5839        impl<'de> serde::Deserialize<'de> for GeneratedField {
5840            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
5841            where
5842                D: serde::Deserializer<'de>,
5843            {
5844                struct GeneratedVisitor;
5845
5846                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5847                    type Value = GeneratedField;
5848
5849                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5850                        write!(formatter, "expected one of: {:?}", &FIELDS)
5851                    }
5852
5853                    #[allow(unused_variables)]
5854                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
5855                    where
5856                        E: serde::de::Error,
5857                    {
5858                        match value {
5859                            "timeCol" | "time_col" => Ok(GeneratedField::TimeCol),
5860                            "windowSlide" | "window_slide" => Ok(GeneratedField::WindowSlide),
5861                            "windowSize" | "window_size" => Ok(GeneratedField::WindowSize),
5862                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
5863                            "windowStartExprs" | "window_start_exprs" => Ok(GeneratedField::WindowStartExprs),
5864                            "windowEndExprs" | "window_end_exprs" => Ok(GeneratedField::WindowEndExprs),
5865                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
5866                        }
5867                    }
5868                }
5869                deserializer.deserialize_identifier(GeneratedVisitor)
5870            }
5871        }
5872        struct GeneratedVisitor;
5873        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
5874            type Value = HopWindowNode;
5875
5876            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5877                formatter.write_str("struct stream_plan.HopWindowNode")
5878            }
5879
5880            fn visit_map<V>(self, mut map_: V) -> std::result::Result<HopWindowNode, V::Error>
5881                where
5882                    V: serde::de::MapAccess<'de>,
5883            {
5884                let mut time_col__ = None;
5885                let mut window_slide__ = None;
5886                let mut window_size__ = None;
5887                let mut output_indices__ = None;
5888                let mut window_start_exprs__ = None;
5889                let mut window_end_exprs__ = None;
5890                while let Some(k) = map_.next_key()? {
5891                    match k {
5892                        GeneratedField::TimeCol => {
5893                            if time_col__.is_some() {
5894                                return Err(serde::de::Error::duplicate_field("timeCol"));
5895                            }
5896                            time_col__ = 
5897                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
5898                            ;
5899                        }
5900                        GeneratedField::WindowSlide => {
5901                            if window_slide__.is_some() {
5902                                return Err(serde::de::Error::duplicate_field("windowSlide"));
5903                            }
5904                            window_slide__ = map_.next_value()?;
5905                        }
5906                        GeneratedField::WindowSize => {
5907                            if window_size__.is_some() {
5908                                return Err(serde::de::Error::duplicate_field("windowSize"));
5909                            }
5910                            window_size__ = map_.next_value()?;
5911                        }
5912                        GeneratedField::OutputIndices => {
5913                            if output_indices__.is_some() {
5914                                return Err(serde::de::Error::duplicate_field("outputIndices"));
5915                            }
5916                            output_indices__ = 
5917                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
5918                                    .into_iter().map(|x| x.0).collect())
5919                            ;
5920                        }
5921                        GeneratedField::WindowStartExprs => {
5922                            if window_start_exprs__.is_some() {
5923                                return Err(serde::de::Error::duplicate_field("windowStartExprs"));
5924                            }
5925                            window_start_exprs__ = Some(map_.next_value()?);
5926                        }
5927                        GeneratedField::WindowEndExprs => {
5928                            if window_end_exprs__.is_some() {
5929                                return Err(serde::de::Error::duplicate_field("windowEndExprs"));
5930                            }
5931                            window_end_exprs__ = Some(map_.next_value()?);
5932                        }
5933                    }
5934                }
5935                Ok(HopWindowNode {
5936                    time_col: time_col__.unwrap_or_default(),
5937                    window_slide: window_slide__,
5938                    window_size: window_size__,
5939                    output_indices: output_indices__.unwrap_or_default(),
5940                    window_start_exprs: window_start_exprs__.unwrap_or_default(),
5941                    window_end_exprs: window_end_exprs__.unwrap_or_default(),
5942                })
5943            }
5944        }
5945        deserializer.deserialize_struct("stream_plan.HopWindowNode", FIELDS, GeneratedVisitor)
5946    }
5947}
5948impl serde::Serialize for InequalityPair {
5949    #[allow(deprecated)]
5950    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
5951    where
5952        S: serde::Serializer,
5953    {
5954        use serde::ser::SerializeStruct;
5955        let mut len = 0;
5956        if self.key_required_larger != 0 {
5957            len += 1;
5958        }
5959        if self.key_required_smaller != 0 {
5960            len += 1;
5961        }
5962        if self.clean_state {
5963            len += 1;
5964        }
5965        if self.delta_expression.is_some() {
5966            len += 1;
5967        }
5968        let mut struct_ser = serializer.serialize_struct("stream_plan.InequalityPair", len)?;
5969        if self.key_required_larger != 0 {
5970            struct_ser.serialize_field("keyRequiredLarger", &self.key_required_larger)?;
5971        }
5972        if self.key_required_smaller != 0 {
5973            struct_ser.serialize_field("keyRequiredSmaller", &self.key_required_smaller)?;
5974        }
5975        if self.clean_state {
5976            struct_ser.serialize_field("cleanState", &self.clean_state)?;
5977        }
5978        if let Some(v) = self.delta_expression.as_ref() {
5979            struct_ser.serialize_field("deltaExpression", v)?;
5980        }
5981        struct_ser.end()
5982    }
5983}
5984impl<'de> serde::Deserialize<'de> for InequalityPair {
5985    #[allow(deprecated)]
5986    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
5987    where
5988        D: serde::Deserializer<'de>,
5989    {
5990        const FIELDS: &[&str] = &[
5991            "key_required_larger",
5992            "keyRequiredLarger",
5993            "key_required_smaller",
5994            "keyRequiredSmaller",
5995            "clean_state",
5996            "cleanState",
5997            "delta_expression",
5998            "deltaExpression",
5999        ];
6000
6001        #[allow(clippy::enum_variant_names)]
6002        enum GeneratedField {
6003            KeyRequiredLarger,
6004            KeyRequiredSmaller,
6005            CleanState,
6006            DeltaExpression,
6007        }
6008        impl<'de> serde::Deserialize<'de> for GeneratedField {
6009            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6010            where
6011                D: serde::Deserializer<'de>,
6012            {
6013                struct GeneratedVisitor;
6014
6015                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6016                    type Value = GeneratedField;
6017
6018                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6019                        write!(formatter, "expected one of: {:?}", &FIELDS)
6020                    }
6021
6022                    #[allow(unused_variables)]
6023                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6024                    where
6025                        E: serde::de::Error,
6026                    {
6027                        match value {
6028                            "keyRequiredLarger" | "key_required_larger" => Ok(GeneratedField::KeyRequiredLarger),
6029                            "keyRequiredSmaller" | "key_required_smaller" => Ok(GeneratedField::KeyRequiredSmaller),
6030                            "cleanState" | "clean_state" => Ok(GeneratedField::CleanState),
6031                            "deltaExpression" | "delta_expression" => Ok(GeneratedField::DeltaExpression),
6032                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6033                        }
6034                    }
6035                }
6036                deserializer.deserialize_identifier(GeneratedVisitor)
6037            }
6038        }
6039        struct GeneratedVisitor;
6040        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6041            type Value = InequalityPair;
6042
6043            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6044                formatter.write_str("struct stream_plan.InequalityPair")
6045            }
6046
6047            fn visit_map<V>(self, mut map_: V) -> std::result::Result<InequalityPair, V::Error>
6048                where
6049                    V: serde::de::MapAccess<'de>,
6050            {
6051                let mut key_required_larger__ = None;
6052                let mut key_required_smaller__ = None;
6053                let mut clean_state__ = None;
6054                let mut delta_expression__ = None;
6055                while let Some(k) = map_.next_key()? {
6056                    match k {
6057                        GeneratedField::KeyRequiredLarger => {
6058                            if key_required_larger__.is_some() {
6059                                return Err(serde::de::Error::duplicate_field("keyRequiredLarger"));
6060                            }
6061                            key_required_larger__ = 
6062                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6063                            ;
6064                        }
6065                        GeneratedField::KeyRequiredSmaller => {
6066                            if key_required_smaller__.is_some() {
6067                                return Err(serde::de::Error::duplicate_field("keyRequiredSmaller"));
6068                            }
6069                            key_required_smaller__ = 
6070                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6071                            ;
6072                        }
6073                        GeneratedField::CleanState => {
6074                            if clean_state__.is_some() {
6075                                return Err(serde::de::Error::duplicate_field("cleanState"));
6076                            }
6077                            clean_state__ = Some(map_.next_value()?);
6078                        }
6079                        GeneratedField::DeltaExpression => {
6080                            if delta_expression__.is_some() {
6081                                return Err(serde::de::Error::duplicate_field("deltaExpression"));
6082                            }
6083                            delta_expression__ = map_.next_value()?;
6084                        }
6085                    }
6086                }
6087                Ok(InequalityPair {
6088                    key_required_larger: key_required_larger__.unwrap_or_default(),
6089                    key_required_smaller: key_required_smaller__.unwrap_or_default(),
6090                    clean_state: clean_state__.unwrap_or_default(),
6091                    delta_expression: delta_expression__,
6092                })
6093            }
6094        }
6095        deserializer.deserialize_struct("stream_plan.InequalityPair", FIELDS, GeneratedVisitor)
6096    }
6097}
6098impl serde::Serialize for JoinEncodingType {
6099    #[allow(deprecated)]
6100    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6101    where
6102        S: serde::Serializer,
6103    {
6104        let variant = match self {
6105            Self::Unspecified => "UNSPECIFIED",
6106            Self::MemoryOptimized => "MEMORY_OPTIMIZED",
6107            Self::CpuOptimized => "CPU_OPTIMIZED",
6108        };
6109        serializer.serialize_str(variant)
6110    }
6111}
6112impl<'de> serde::Deserialize<'de> for JoinEncodingType {
6113    #[allow(deprecated)]
6114    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6115    where
6116        D: serde::Deserializer<'de>,
6117    {
6118        const FIELDS: &[&str] = &[
6119            "UNSPECIFIED",
6120            "MEMORY_OPTIMIZED",
6121            "CPU_OPTIMIZED",
6122        ];
6123
6124        struct GeneratedVisitor;
6125
6126        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6127            type Value = JoinEncodingType;
6128
6129            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6130                write!(formatter, "expected one of: {:?}", &FIELDS)
6131            }
6132
6133            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
6134            where
6135                E: serde::de::Error,
6136            {
6137                i32::try_from(v)
6138                    .ok()
6139                    .and_then(|x| x.try_into().ok())
6140                    .ok_or_else(|| {
6141                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
6142                    })
6143            }
6144
6145            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
6146            where
6147                E: serde::de::Error,
6148            {
6149                i32::try_from(v)
6150                    .ok()
6151                    .and_then(|x| x.try_into().ok())
6152                    .ok_or_else(|| {
6153                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
6154                    })
6155            }
6156
6157            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
6158            where
6159                E: serde::de::Error,
6160            {
6161                match value {
6162                    "UNSPECIFIED" => Ok(JoinEncodingType::Unspecified),
6163                    "MEMORY_OPTIMIZED" => Ok(JoinEncodingType::MemoryOptimized),
6164                    "CPU_OPTIMIZED" => Ok(JoinEncodingType::CpuOptimized),
6165                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
6166                }
6167            }
6168        }
6169        deserializer.deserialize_any(GeneratedVisitor)
6170    }
6171}
6172impl serde::Serialize for LoadFinishMutation {
6173    #[allow(deprecated)]
6174    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6175    where
6176        S: serde::Serializer,
6177    {
6178        use serde::ser::SerializeStruct;
6179        let mut len = 0;
6180        if self.associated_source_id != 0 {
6181            len += 1;
6182        }
6183        let mut struct_ser = serializer.serialize_struct("stream_plan.LoadFinishMutation", len)?;
6184        if self.associated_source_id != 0 {
6185            struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
6186        }
6187        struct_ser.end()
6188    }
6189}
6190impl<'de> serde::Deserialize<'de> for LoadFinishMutation {
6191    #[allow(deprecated)]
6192    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6193    where
6194        D: serde::Deserializer<'de>,
6195    {
6196        const FIELDS: &[&str] = &[
6197            "associated_source_id",
6198            "associatedSourceId",
6199        ];
6200
6201        #[allow(clippy::enum_variant_names)]
6202        enum GeneratedField {
6203            AssociatedSourceId,
6204        }
6205        impl<'de> serde::Deserialize<'de> for GeneratedField {
6206            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6207            where
6208                D: serde::Deserializer<'de>,
6209            {
6210                struct GeneratedVisitor;
6211
6212                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6213                    type Value = GeneratedField;
6214
6215                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6216                        write!(formatter, "expected one of: {:?}", &FIELDS)
6217                    }
6218
6219                    #[allow(unused_variables)]
6220                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6221                    where
6222                        E: serde::de::Error,
6223                    {
6224                        match value {
6225                            "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
6226                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6227                        }
6228                    }
6229                }
6230                deserializer.deserialize_identifier(GeneratedVisitor)
6231            }
6232        }
6233        struct GeneratedVisitor;
6234        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6235            type Value = LoadFinishMutation;
6236
6237            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6238                formatter.write_str("struct stream_plan.LoadFinishMutation")
6239            }
6240
6241            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LoadFinishMutation, V::Error>
6242                where
6243                    V: serde::de::MapAccess<'de>,
6244            {
6245                let mut associated_source_id__ = None;
6246                while let Some(k) = map_.next_key()? {
6247                    match k {
6248                        GeneratedField::AssociatedSourceId => {
6249                            if associated_source_id__.is_some() {
6250                                return Err(serde::de::Error::duplicate_field("associatedSourceId"));
6251                            }
6252                            associated_source_id__ = 
6253                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6254                            ;
6255                        }
6256                    }
6257                }
6258                Ok(LoadFinishMutation {
6259                    associated_source_id: associated_source_id__.unwrap_or_default(),
6260                })
6261            }
6262        }
6263        deserializer.deserialize_struct("stream_plan.LoadFinishMutation", FIELDS, GeneratedVisitor)
6264    }
6265}
6266impl serde::Serialize for LocalApproxPercentileNode {
6267    #[allow(deprecated)]
6268    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6269    where
6270        S: serde::Serializer,
6271    {
6272        use serde::ser::SerializeStruct;
6273        let mut len = 0;
6274        if self.base != 0. {
6275            len += 1;
6276        }
6277        if self.percentile_index != 0 {
6278            len += 1;
6279        }
6280        let mut struct_ser = serializer.serialize_struct("stream_plan.LocalApproxPercentileNode", len)?;
6281        if self.base != 0. {
6282            struct_ser.serialize_field("base", &self.base)?;
6283        }
6284        if self.percentile_index != 0 {
6285            struct_ser.serialize_field("percentileIndex", &self.percentile_index)?;
6286        }
6287        struct_ser.end()
6288    }
6289}
6290impl<'de> serde::Deserialize<'de> for LocalApproxPercentileNode {
6291    #[allow(deprecated)]
6292    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6293    where
6294        D: serde::Deserializer<'de>,
6295    {
6296        const FIELDS: &[&str] = &[
6297            "base",
6298            "percentile_index",
6299            "percentileIndex",
6300        ];
6301
6302        #[allow(clippy::enum_variant_names)]
6303        enum GeneratedField {
6304            Base,
6305            PercentileIndex,
6306        }
6307        impl<'de> serde::Deserialize<'de> for GeneratedField {
6308            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6309            where
6310                D: serde::Deserializer<'de>,
6311            {
6312                struct GeneratedVisitor;
6313
6314                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6315                    type Value = GeneratedField;
6316
6317                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6318                        write!(formatter, "expected one of: {:?}", &FIELDS)
6319                    }
6320
6321                    #[allow(unused_variables)]
6322                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6323                    where
6324                        E: serde::de::Error,
6325                    {
6326                        match value {
6327                            "base" => Ok(GeneratedField::Base),
6328                            "percentileIndex" | "percentile_index" => Ok(GeneratedField::PercentileIndex),
6329                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6330                        }
6331                    }
6332                }
6333                deserializer.deserialize_identifier(GeneratedVisitor)
6334            }
6335        }
6336        struct GeneratedVisitor;
6337        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6338            type Value = LocalApproxPercentileNode;
6339
6340            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6341                formatter.write_str("struct stream_plan.LocalApproxPercentileNode")
6342            }
6343
6344            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LocalApproxPercentileNode, V::Error>
6345                where
6346                    V: serde::de::MapAccess<'de>,
6347            {
6348                let mut base__ = None;
6349                let mut percentile_index__ = None;
6350                while let Some(k) = map_.next_key()? {
6351                    match k {
6352                        GeneratedField::Base => {
6353                            if base__.is_some() {
6354                                return Err(serde::de::Error::duplicate_field("base"));
6355                            }
6356                            base__ = 
6357                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6358                            ;
6359                        }
6360                        GeneratedField::PercentileIndex => {
6361                            if percentile_index__.is_some() {
6362                                return Err(serde::de::Error::duplicate_field("percentileIndex"));
6363                            }
6364                            percentile_index__ = 
6365                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6366                            ;
6367                        }
6368                    }
6369                }
6370                Ok(LocalApproxPercentileNode {
6371                    base: base__.unwrap_or_default(),
6372                    percentile_index: percentile_index__.unwrap_or_default(),
6373                })
6374            }
6375        }
6376        deserializer.deserialize_struct("stream_plan.LocalApproxPercentileNode", FIELDS, GeneratedVisitor)
6377    }
6378}
6379impl serde::Serialize for LookupNode {
6380    #[allow(deprecated)]
6381    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6382    where
6383        S: serde::Serializer,
6384    {
6385        use serde::ser::SerializeStruct;
6386        let mut len = 0;
6387        if !self.arrange_key.is_empty() {
6388            len += 1;
6389        }
6390        if !self.stream_key.is_empty() {
6391            len += 1;
6392        }
6393        if self.use_current_epoch {
6394            len += 1;
6395        }
6396        if !self.column_mapping.is_empty() {
6397            len += 1;
6398        }
6399        if self.arrangement_table_info.is_some() {
6400            len += 1;
6401        }
6402        if self.arrangement_table_id.is_some() {
6403            len += 1;
6404        }
6405        let mut struct_ser = serializer.serialize_struct("stream_plan.LookupNode", len)?;
6406        if !self.arrange_key.is_empty() {
6407            struct_ser.serialize_field("arrangeKey", &self.arrange_key)?;
6408        }
6409        if !self.stream_key.is_empty() {
6410            struct_ser.serialize_field("streamKey", &self.stream_key)?;
6411        }
6412        if self.use_current_epoch {
6413            struct_ser.serialize_field("useCurrentEpoch", &self.use_current_epoch)?;
6414        }
6415        if !self.column_mapping.is_empty() {
6416            struct_ser.serialize_field("columnMapping", &self.column_mapping)?;
6417        }
6418        if let Some(v) = self.arrangement_table_info.as_ref() {
6419            struct_ser.serialize_field("arrangementTableInfo", v)?;
6420        }
6421        if let Some(v) = self.arrangement_table_id.as_ref() {
6422            match v {
6423                lookup_node::ArrangementTableId::TableId(v) => {
6424                    struct_ser.serialize_field("tableId", v)?;
6425                }
6426                lookup_node::ArrangementTableId::IndexId(v) => {
6427                    struct_ser.serialize_field("indexId", v)?;
6428                }
6429            }
6430        }
6431        struct_ser.end()
6432    }
6433}
6434impl<'de> serde::Deserialize<'de> for LookupNode {
6435    #[allow(deprecated)]
6436    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6437    where
6438        D: serde::Deserializer<'de>,
6439    {
6440        const FIELDS: &[&str] = &[
6441            "arrange_key",
6442            "arrangeKey",
6443            "stream_key",
6444            "streamKey",
6445            "use_current_epoch",
6446            "useCurrentEpoch",
6447            "column_mapping",
6448            "columnMapping",
6449            "arrangement_table_info",
6450            "arrangementTableInfo",
6451            "table_id",
6452            "tableId",
6453            "index_id",
6454            "indexId",
6455        ];
6456
6457        #[allow(clippy::enum_variant_names)]
6458        enum GeneratedField {
6459            ArrangeKey,
6460            StreamKey,
6461            UseCurrentEpoch,
6462            ColumnMapping,
6463            ArrangementTableInfo,
6464            TableId,
6465            IndexId,
6466        }
6467        impl<'de> serde::Deserialize<'de> for GeneratedField {
6468            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6469            where
6470                D: serde::Deserializer<'de>,
6471            {
6472                struct GeneratedVisitor;
6473
6474                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6475                    type Value = GeneratedField;
6476
6477                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6478                        write!(formatter, "expected one of: {:?}", &FIELDS)
6479                    }
6480
6481                    #[allow(unused_variables)]
6482                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6483                    where
6484                        E: serde::de::Error,
6485                    {
6486                        match value {
6487                            "arrangeKey" | "arrange_key" => Ok(GeneratedField::ArrangeKey),
6488                            "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
6489                            "useCurrentEpoch" | "use_current_epoch" => Ok(GeneratedField::UseCurrentEpoch),
6490                            "columnMapping" | "column_mapping" => Ok(GeneratedField::ColumnMapping),
6491                            "arrangementTableInfo" | "arrangement_table_info" => Ok(GeneratedField::ArrangementTableInfo),
6492                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
6493                            "indexId" | "index_id" => Ok(GeneratedField::IndexId),
6494                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6495                        }
6496                    }
6497                }
6498                deserializer.deserialize_identifier(GeneratedVisitor)
6499            }
6500        }
6501        struct GeneratedVisitor;
6502        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6503            type Value = LookupNode;
6504
6505            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6506                formatter.write_str("struct stream_plan.LookupNode")
6507            }
6508
6509            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupNode, V::Error>
6510                where
6511                    V: serde::de::MapAccess<'de>,
6512            {
6513                let mut arrange_key__ = None;
6514                let mut stream_key__ = None;
6515                let mut use_current_epoch__ = None;
6516                let mut column_mapping__ = None;
6517                let mut arrangement_table_info__ = None;
6518                let mut arrangement_table_id__ = None;
6519                while let Some(k) = map_.next_key()? {
6520                    match k {
6521                        GeneratedField::ArrangeKey => {
6522                            if arrange_key__.is_some() {
6523                                return Err(serde::de::Error::duplicate_field("arrangeKey"));
6524                            }
6525                            arrange_key__ = 
6526                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6527                                    .into_iter().map(|x| x.0).collect())
6528                            ;
6529                        }
6530                        GeneratedField::StreamKey => {
6531                            if stream_key__.is_some() {
6532                                return Err(serde::de::Error::duplicate_field("streamKey"));
6533                            }
6534                            stream_key__ = 
6535                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6536                                    .into_iter().map(|x| x.0).collect())
6537                            ;
6538                        }
6539                        GeneratedField::UseCurrentEpoch => {
6540                            if use_current_epoch__.is_some() {
6541                                return Err(serde::de::Error::duplicate_field("useCurrentEpoch"));
6542                            }
6543                            use_current_epoch__ = Some(map_.next_value()?);
6544                        }
6545                        GeneratedField::ColumnMapping => {
6546                            if column_mapping__.is_some() {
6547                                return Err(serde::de::Error::duplicate_field("columnMapping"));
6548                            }
6549                            column_mapping__ = 
6550                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6551                                    .into_iter().map(|x| x.0).collect())
6552                            ;
6553                        }
6554                        GeneratedField::ArrangementTableInfo => {
6555                            if arrangement_table_info__.is_some() {
6556                                return Err(serde::de::Error::duplicate_field("arrangementTableInfo"));
6557                            }
6558                            arrangement_table_info__ = map_.next_value()?;
6559                        }
6560                        GeneratedField::TableId => {
6561                            if arrangement_table_id__.is_some() {
6562                                return Err(serde::de::Error::duplicate_field("tableId"));
6563                            }
6564                            arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::TableId(x.0));
6565                        }
6566                        GeneratedField::IndexId => {
6567                            if arrangement_table_id__.is_some() {
6568                                return Err(serde::de::Error::duplicate_field("indexId"));
6569                            }
6570                            arrangement_table_id__ = map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| lookup_node::ArrangementTableId::IndexId(x.0));
6571                        }
6572                    }
6573                }
6574                Ok(LookupNode {
6575                    arrange_key: arrange_key__.unwrap_or_default(),
6576                    stream_key: stream_key__.unwrap_or_default(),
6577                    use_current_epoch: use_current_epoch__.unwrap_or_default(),
6578                    column_mapping: column_mapping__.unwrap_or_default(),
6579                    arrangement_table_info: arrangement_table_info__,
6580                    arrangement_table_id: arrangement_table_id__,
6581                })
6582            }
6583        }
6584        deserializer.deserialize_struct("stream_plan.LookupNode", FIELDS, GeneratedVisitor)
6585    }
6586}
6587impl serde::Serialize for LookupUnionNode {
6588    #[allow(deprecated)]
6589    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6590    where
6591        S: serde::Serializer,
6592    {
6593        use serde::ser::SerializeStruct;
6594        let mut len = 0;
6595        if !self.order.is_empty() {
6596            len += 1;
6597        }
6598        let mut struct_ser = serializer.serialize_struct("stream_plan.LookupUnionNode", len)?;
6599        if !self.order.is_empty() {
6600            struct_ser.serialize_field("order", &self.order)?;
6601        }
6602        struct_ser.end()
6603    }
6604}
6605impl<'de> serde::Deserialize<'de> for LookupUnionNode {
6606    #[allow(deprecated)]
6607    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6608    where
6609        D: serde::Deserializer<'de>,
6610    {
6611        const FIELDS: &[&str] = &[
6612            "order",
6613        ];
6614
6615        #[allow(clippy::enum_variant_names)]
6616        enum GeneratedField {
6617            Order,
6618        }
6619        impl<'de> serde::Deserialize<'de> for GeneratedField {
6620            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6621            where
6622                D: serde::Deserializer<'de>,
6623            {
6624                struct GeneratedVisitor;
6625
6626                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6627                    type Value = GeneratedField;
6628
6629                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6630                        write!(formatter, "expected one of: {:?}", &FIELDS)
6631                    }
6632
6633                    #[allow(unused_variables)]
6634                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6635                    where
6636                        E: serde::de::Error,
6637                    {
6638                        match value {
6639                            "order" => Ok(GeneratedField::Order),
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 = LookupUnionNode;
6650
6651            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6652                formatter.write_str("struct stream_plan.LookupUnionNode")
6653            }
6654
6655            fn visit_map<V>(self, mut map_: V) -> std::result::Result<LookupUnionNode, V::Error>
6656                where
6657                    V: serde::de::MapAccess<'de>,
6658            {
6659                let mut order__ = None;
6660                while let Some(k) = map_.next_key()? {
6661                    match k {
6662                        GeneratedField::Order => {
6663                            if order__.is_some() {
6664                                return Err(serde::de::Error::duplicate_field("order"));
6665                            }
6666                            order__ = 
6667                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
6668                                    .into_iter().map(|x| x.0).collect())
6669                            ;
6670                        }
6671                    }
6672                }
6673                Ok(LookupUnionNode {
6674                    order: order__.unwrap_or_default(),
6675                })
6676            }
6677        }
6678        deserializer.deserialize_struct("stream_plan.LookupUnionNode", FIELDS, GeneratedVisitor)
6679    }
6680}
6681impl serde::Serialize for MaterializeNode {
6682    #[allow(deprecated)]
6683    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6684    where
6685        S: serde::Serializer,
6686    {
6687        use serde::ser::SerializeStruct;
6688        let mut len = 0;
6689        if self.table_id != 0 {
6690            len += 1;
6691        }
6692        if !self.column_orders.is_empty() {
6693            len += 1;
6694        }
6695        if self.table.is_some() {
6696            len += 1;
6697        }
6698        let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializeNode", len)?;
6699        if self.table_id != 0 {
6700            struct_ser.serialize_field("tableId", &self.table_id)?;
6701        }
6702        if !self.column_orders.is_empty() {
6703            struct_ser.serialize_field("columnOrders", &self.column_orders)?;
6704        }
6705        if let Some(v) = self.table.as_ref() {
6706            struct_ser.serialize_field("table", v)?;
6707        }
6708        struct_ser.end()
6709    }
6710}
6711impl<'de> serde::Deserialize<'de> for MaterializeNode {
6712    #[allow(deprecated)]
6713    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6714    where
6715        D: serde::Deserializer<'de>,
6716    {
6717        const FIELDS: &[&str] = &[
6718            "table_id",
6719            "tableId",
6720            "column_orders",
6721            "columnOrders",
6722            "table",
6723        ];
6724
6725        #[allow(clippy::enum_variant_names)]
6726        enum GeneratedField {
6727            TableId,
6728            ColumnOrders,
6729            Table,
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                        match value {
6751                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
6752                            "columnOrders" | "column_orders" => Ok(GeneratedField::ColumnOrders),
6753                            "table" => Ok(GeneratedField::Table),
6754                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6755                        }
6756                    }
6757                }
6758                deserializer.deserialize_identifier(GeneratedVisitor)
6759            }
6760        }
6761        struct GeneratedVisitor;
6762        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6763            type Value = MaterializeNode;
6764
6765            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6766                formatter.write_str("struct stream_plan.MaterializeNode")
6767            }
6768
6769            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializeNode, V::Error>
6770                where
6771                    V: serde::de::MapAccess<'de>,
6772            {
6773                let mut table_id__ = None;
6774                let mut column_orders__ = None;
6775                let mut table__ = None;
6776                while let Some(k) = map_.next_key()? {
6777                    match k {
6778                        GeneratedField::TableId => {
6779                            if table_id__.is_some() {
6780                                return Err(serde::de::Error::duplicate_field("tableId"));
6781                            }
6782                            table_id__ = 
6783                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
6784                            ;
6785                        }
6786                        GeneratedField::ColumnOrders => {
6787                            if column_orders__.is_some() {
6788                                return Err(serde::de::Error::duplicate_field("columnOrders"));
6789                            }
6790                            column_orders__ = Some(map_.next_value()?);
6791                        }
6792                        GeneratedField::Table => {
6793                            if table__.is_some() {
6794                                return Err(serde::de::Error::duplicate_field("table"));
6795                            }
6796                            table__ = map_.next_value()?;
6797                        }
6798                    }
6799                }
6800                Ok(MaterializeNode {
6801                    table_id: table_id__.unwrap_or_default(),
6802                    column_orders: column_orders__.unwrap_or_default(),
6803                    table: table__,
6804                })
6805            }
6806        }
6807        deserializer.deserialize_struct("stream_plan.MaterializeNode", FIELDS, GeneratedVisitor)
6808    }
6809}
6810impl serde::Serialize for MaterializedExprsNode {
6811    #[allow(deprecated)]
6812    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6813    where
6814        S: serde::Serializer,
6815    {
6816        use serde::ser::SerializeStruct;
6817        let mut len = 0;
6818        if !self.exprs.is_empty() {
6819            len += 1;
6820        }
6821        if self.state_table.is_some() {
6822            len += 1;
6823        }
6824        if self.state_clean_col_idx.is_some() {
6825            len += 1;
6826        }
6827        let mut struct_ser = serializer.serialize_struct("stream_plan.MaterializedExprsNode", len)?;
6828        if !self.exprs.is_empty() {
6829            struct_ser.serialize_field("exprs", &self.exprs)?;
6830        }
6831        if let Some(v) = self.state_table.as_ref() {
6832            struct_ser.serialize_field("stateTable", v)?;
6833        }
6834        if let Some(v) = self.state_clean_col_idx.as_ref() {
6835            struct_ser.serialize_field("stateCleanColIdx", v)?;
6836        }
6837        struct_ser.end()
6838    }
6839}
6840impl<'de> serde::Deserialize<'de> for MaterializedExprsNode {
6841    #[allow(deprecated)]
6842    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6843    where
6844        D: serde::Deserializer<'de>,
6845    {
6846        const FIELDS: &[&str] = &[
6847            "exprs",
6848            "state_table",
6849            "stateTable",
6850            "state_clean_col_idx",
6851            "stateCleanColIdx",
6852        ];
6853
6854        #[allow(clippy::enum_variant_names)]
6855        enum GeneratedField {
6856            Exprs,
6857            StateTable,
6858            StateCleanColIdx,
6859        }
6860        impl<'de> serde::Deserialize<'de> for GeneratedField {
6861            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
6862            where
6863                D: serde::Deserializer<'de>,
6864            {
6865                struct GeneratedVisitor;
6866
6867                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6868                    type Value = GeneratedField;
6869
6870                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6871                        write!(formatter, "expected one of: {:?}", &FIELDS)
6872                    }
6873
6874                    #[allow(unused_variables)]
6875                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
6876                    where
6877                        E: serde::de::Error,
6878                    {
6879                        match value {
6880                            "exprs" => Ok(GeneratedField::Exprs),
6881                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
6882                            "stateCleanColIdx" | "state_clean_col_idx" => Ok(GeneratedField::StateCleanColIdx),
6883                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
6884                        }
6885                    }
6886                }
6887                deserializer.deserialize_identifier(GeneratedVisitor)
6888            }
6889        }
6890        struct GeneratedVisitor;
6891        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
6892            type Value = MaterializedExprsNode;
6893
6894            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6895                formatter.write_str("struct stream_plan.MaterializedExprsNode")
6896            }
6897
6898            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MaterializedExprsNode, V::Error>
6899                where
6900                    V: serde::de::MapAccess<'de>,
6901            {
6902                let mut exprs__ = None;
6903                let mut state_table__ = None;
6904                let mut state_clean_col_idx__ = None;
6905                while let Some(k) = map_.next_key()? {
6906                    match k {
6907                        GeneratedField::Exprs => {
6908                            if exprs__.is_some() {
6909                                return Err(serde::de::Error::duplicate_field("exprs"));
6910                            }
6911                            exprs__ = Some(map_.next_value()?);
6912                        }
6913                        GeneratedField::StateTable => {
6914                            if state_table__.is_some() {
6915                                return Err(serde::de::Error::duplicate_field("stateTable"));
6916                            }
6917                            state_table__ = map_.next_value()?;
6918                        }
6919                        GeneratedField::StateCleanColIdx => {
6920                            if state_clean_col_idx__.is_some() {
6921                                return Err(serde::de::Error::duplicate_field("stateCleanColIdx"));
6922                            }
6923                            state_clean_col_idx__ = 
6924                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
6925                            ;
6926                        }
6927                    }
6928                }
6929                Ok(MaterializedExprsNode {
6930                    exprs: exprs__.unwrap_or_default(),
6931                    state_table: state_table__,
6932                    state_clean_col_idx: state_clean_col_idx__,
6933                })
6934            }
6935        }
6936        deserializer.deserialize_struct("stream_plan.MaterializedExprsNode", FIELDS, GeneratedVisitor)
6937    }
6938}
6939impl serde::Serialize for MergeNode {
6940    #[allow(deprecated)]
6941    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
6942    where
6943        S: serde::Serializer,
6944    {
6945        use serde::ser::SerializeStruct;
6946        let mut len = 0;
6947        if !self.upstream_actor_id.is_empty() {
6948            len += 1;
6949        }
6950        if self.upstream_fragment_id != 0 {
6951            len += 1;
6952        }
6953        if self.upstream_dispatcher_type != 0 {
6954            len += 1;
6955        }
6956        if !self.fields.is_empty() {
6957            len += 1;
6958        }
6959        let mut struct_ser = serializer.serialize_struct("stream_plan.MergeNode", len)?;
6960        if !self.upstream_actor_id.is_empty() {
6961            struct_ser.serialize_field("upstreamActorId", &self.upstream_actor_id)?;
6962        }
6963        if self.upstream_fragment_id != 0 {
6964            struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
6965        }
6966        if self.upstream_dispatcher_type != 0 {
6967            let v = DispatcherType::try_from(self.upstream_dispatcher_type)
6968                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.upstream_dispatcher_type)))?;
6969            struct_ser.serialize_field("upstreamDispatcherType", &v)?;
6970        }
6971        if !self.fields.is_empty() {
6972            struct_ser.serialize_field("fields", &self.fields)?;
6973        }
6974        struct_ser.end()
6975    }
6976}
6977impl<'de> serde::Deserialize<'de> for MergeNode {
6978    #[allow(deprecated)]
6979    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
6980    where
6981        D: serde::Deserializer<'de>,
6982    {
6983        const FIELDS: &[&str] = &[
6984            "upstream_actor_id",
6985            "upstreamActorId",
6986            "upstream_fragment_id",
6987            "upstreamFragmentId",
6988            "upstream_dispatcher_type",
6989            "upstreamDispatcherType",
6990            "fields",
6991        ];
6992
6993        #[allow(clippy::enum_variant_names)]
6994        enum GeneratedField {
6995            UpstreamActorId,
6996            UpstreamFragmentId,
6997            UpstreamDispatcherType,
6998            Fields,
6999        }
7000        impl<'de> serde::Deserialize<'de> for GeneratedField {
7001            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7002            where
7003                D: serde::Deserializer<'de>,
7004            {
7005                struct GeneratedVisitor;
7006
7007                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7008                    type Value = GeneratedField;
7009
7010                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7011                        write!(formatter, "expected one of: {:?}", &FIELDS)
7012                    }
7013
7014                    #[allow(unused_variables)]
7015                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7016                    where
7017                        E: serde::de::Error,
7018                    {
7019                        match value {
7020                            "upstreamActorId" | "upstream_actor_id" => Ok(GeneratedField::UpstreamActorId),
7021                            "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
7022                            "upstreamDispatcherType" | "upstream_dispatcher_type" => Ok(GeneratedField::UpstreamDispatcherType),
7023                            "fields" => Ok(GeneratedField::Fields),
7024                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7025                        }
7026                    }
7027                }
7028                deserializer.deserialize_identifier(GeneratedVisitor)
7029            }
7030        }
7031        struct GeneratedVisitor;
7032        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7033            type Value = MergeNode;
7034
7035            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7036                formatter.write_str("struct stream_plan.MergeNode")
7037            }
7038
7039            fn visit_map<V>(self, mut map_: V) -> std::result::Result<MergeNode, V::Error>
7040                where
7041                    V: serde::de::MapAccess<'de>,
7042            {
7043                let mut upstream_actor_id__ = None;
7044                let mut upstream_fragment_id__ = None;
7045                let mut upstream_dispatcher_type__ = None;
7046                let mut fields__ = None;
7047                while let Some(k) = map_.next_key()? {
7048                    match k {
7049                        GeneratedField::UpstreamActorId => {
7050                            if upstream_actor_id__.is_some() {
7051                                return Err(serde::de::Error::duplicate_field("upstreamActorId"));
7052                            }
7053                            upstream_actor_id__ = 
7054                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7055                                    .into_iter().map(|x| x.0).collect())
7056                            ;
7057                        }
7058                        GeneratedField::UpstreamFragmentId => {
7059                            if upstream_fragment_id__.is_some() {
7060                                return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
7061                            }
7062                            upstream_fragment_id__ = 
7063                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
7064                            ;
7065                        }
7066                        GeneratedField::UpstreamDispatcherType => {
7067                            if upstream_dispatcher_type__.is_some() {
7068                                return Err(serde::de::Error::duplicate_field("upstreamDispatcherType"));
7069                            }
7070                            upstream_dispatcher_type__ = Some(map_.next_value::<DispatcherType>()? as i32);
7071                        }
7072                        GeneratedField::Fields => {
7073                            if fields__.is_some() {
7074                                return Err(serde::de::Error::duplicate_field("fields"));
7075                            }
7076                            fields__ = Some(map_.next_value()?);
7077                        }
7078                    }
7079                }
7080                Ok(MergeNode {
7081                    upstream_actor_id: upstream_actor_id__.unwrap_or_default(),
7082                    upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
7083                    upstream_dispatcher_type: upstream_dispatcher_type__.unwrap_or_default(),
7084                    fields: fields__.unwrap_or_default(),
7085                })
7086            }
7087        }
7088        deserializer.deserialize_struct("stream_plan.MergeNode", FIELDS, GeneratedVisitor)
7089    }
7090}
7091impl serde::Serialize for NoOpNode {
7092    #[allow(deprecated)]
7093    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7094    where
7095        S: serde::Serializer,
7096    {
7097        use serde::ser::SerializeStruct;
7098        let len = 0;
7099        let struct_ser = serializer.serialize_struct("stream_plan.NoOpNode", len)?;
7100        struct_ser.end()
7101    }
7102}
7103impl<'de> serde::Deserialize<'de> for NoOpNode {
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        ];
7111
7112        #[allow(clippy::enum_variant_names)]
7113        enum GeneratedField {
7114        }
7115        impl<'de> serde::Deserialize<'de> for GeneratedField {
7116            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7117            where
7118                D: serde::Deserializer<'de>,
7119            {
7120                struct GeneratedVisitor;
7121
7122                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7123                    type Value = GeneratedField;
7124
7125                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7126                        write!(formatter, "expected one of: {:?}", &FIELDS)
7127                    }
7128
7129                    #[allow(unused_variables)]
7130                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7131                    where
7132                        E: serde::de::Error,
7133                    {
7134                            Err(serde::de::Error::unknown_field(value, FIELDS))
7135                    }
7136                }
7137                deserializer.deserialize_identifier(GeneratedVisitor)
7138            }
7139        }
7140        struct GeneratedVisitor;
7141        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7142            type Value = NoOpNode;
7143
7144            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7145                formatter.write_str("struct stream_plan.NoOpNode")
7146            }
7147
7148            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NoOpNode, V::Error>
7149                where
7150                    V: serde::de::MapAccess<'de>,
7151            {
7152                while map_.next_key::<GeneratedField>()?.is_some() {
7153                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7154                }
7155                Ok(NoOpNode {
7156                })
7157            }
7158        }
7159        deserializer.deserialize_struct("stream_plan.NoOpNode", FIELDS, GeneratedVisitor)
7160    }
7161}
7162impl serde::Serialize for NowModeGenerateSeries {
7163    #[allow(deprecated)]
7164    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7165    where
7166        S: serde::Serializer,
7167    {
7168        use serde::ser::SerializeStruct;
7169        let mut len = 0;
7170        if self.start_timestamp.is_some() {
7171            len += 1;
7172        }
7173        if self.interval.is_some() {
7174            len += 1;
7175        }
7176        let mut struct_ser = serializer.serialize_struct("stream_plan.NowModeGenerateSeries", len)?;
7177        if let Some(v) = self.start_timestamp.as_ref() {
7178            struct_ser.serialize_field("startTimestamp", v)?;
7179        }
7180        if let Some(v) = self.interval.as_ref() {
7181            struct_ser.serialize_field("interval", v)?;
7182        }
7183        struct_ser.end()
7184    }
7185}
7186impl<'de> serde::Deserialize<'de> for NowModeGenerateSeries {
7187    #[allow(deprecated)]
7188    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7189    where
7190        D: serde::Deserializer<'de>,
7191    {
7192        const FIELDS: &[&str] = &[
7193            "start_timestamp",
7194            "startTimestamp",
7195            "interval",
7196        ];
7197
7198        #[allow(clippy::enum_variant_names)]
7199        enum GeneratedField {
7200            StartTimestamp,
7201            Interval,
7202        }
7203        impl<'de> serde::Deserialize<'de> for GeneratedField {
7204            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7205            where
7206                D: serde::Deserializer<'de>,
7207            {
7208                struct GeneratedVisitor;
7209
7210                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7211                    type Value = GeneratedField;
7212
7213                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7214                        write!(formatter, "expected one of: {:?}", &FIELDS)
7215                    }
7216
7217                    #[allow(unused_variables)]
7218                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7219                    where
7220                        E: serde::de::Error,
7221                    {
7222                        match value {
7223                            "startTimestamp" | "start_timestamp" => Ok(GeneratedField::StartTimestamp),
7224                            "interval" => Ok(GeneratedField::Interval),
7225                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7226                        }
7227                    }
7228                }
7229                deserializer.deserialize_identifier(GeneratedVisitor)
7230            }
7231        }
7232        struct GeneratedVisitor;
7233        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7234            type Value = NowModeGenerateSeries;
7235
7236            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7237                formatter.write_str("struct stream_plan.NowModeGenerateSeries")
7238            }
7239
7240            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeGenerateSeries, V::Error>
7241                where
7242                    V: serde::de::MapAccess<'de>,
7243            {
7244                let mut start_timestamp__ = None;
7245                let mut interval__ = None;
7246                while let Some(k) = map_.next_key()? {
7247                    match k {
7248                        GeneratedField::StartTimestamp => {
7249                            if start_timestamp__.is_some() {
7250                                return Err(serde::de::Error::duplicate_field("startTimestamp"));
7251                            }
7252                            start_timestamp__ = map_.next_value()?;
7253                        }
7254                        GeneratedField::Interval => {
7255                            if interval__.is_some() {
7256                                return Err(serde::de::Error::duplicate_field("interval"));
7257                            }
7258                            interval__ = map_.next_value()?;
7259                        }
7260                    }
7261                }
7262                Ok(NowModeGenerateSeries {
7263                    start_timestamp: start_timestamp__,
7264                    interval: interval__,
7265                })
7266            }
7267        }
7268        deserializer.deserialize_struct("stream_plan.NowModeGenerateSeries", FIELDS, GeneratedVisitor)
7269    }
7270}
7271impl serde::Serialize for NowModeUpdateCurrent {
7272    #[allow(deprecated)]
7273    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7274    where
7275        S: serde::Serializer,
7276    {
7277        use serde::ser::SerializeStruct;
7278        let len = 0;
7279        let struct_ser = serializer.serialize_struct("stream_plan.NowModeUpdateCurrent", len)?;
7280        struct_ser.end()
7281    }
7282}
7283impl<'de> serde::Deserialize<'de> for NowModeUpdateCurrent {
7284    #[allow(deprecated)]
7285    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7286    where
7287        D: serde::Deserializer<'de>,
7288    {
7289        const FIELDS: &[&str] = &[
7290        ];
7291
7292        #[allow(clippy::enum_variant_names)]
7293        enum GeneratedField {
7294        }
7295        impl<'de> serde::Deserialize<'de> for GeneratedField {
7296            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7297            where
7298                D: serde::Deserializer<'de>,
7299            {
7300                struct GeneratedVisitor;
7301
7302                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7303                    type Value = GeneratedField;
7304
7305                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7306                        write!(formatter, "expected one of: {:?}", &FIELDS)
7307                    }
7308
7309                    #[allow(unused_variables)]
7310                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7311                    where
7312                        E: serde::de::Error,
7313                    {
7314                            Err(serde::de::Error::unknown_field(value, FIELDS))
7315                    }
7316                }
7317                deserializer.deserialize_identifier(GeneratedVisitor)
7318            }
7319        }
7320        struct GeneratedVisitor;
7321        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7322            type Value = NowModeUpdateCurrent;
7323
7324            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7325                formatter.write_str("struct stream_plan.NowModeUpdateCurrent")
7326            }
7327
7328            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowModeUpdateCurrent, V::Error>
7329                where
7330                    V: serde::de::MapAccess<'de>,
7331            {
7332                while map_.next_key::<GeneratedField>()?.is_some() {
7333                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7334                }
7335                Ok(NowModeUpdateCurrent {
7336                })
7337            }
7338        }
7339        deserializer.deserialize_struct("stream_plan.NowModeUpdateCurrent", FIELDS, GeneratedVisitor)
7340    }
7341}
7342impl serde::Serialize for NowNode {
7343    #[allow(deprecated)]
7344    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7345    where
7346        S: serde::Serializer,
7347    {
7348        use serde::ser::SerializeStruct;
7349        let mut len = 0;
7350        if self.state_table.is_some() {
7351            len += 1;
7352        }
7353        if self.mode.is_some() {
7354            len += 1;
7355        }
7356        let mut struct_ser = serializer.serialize_struct("stream_plan.NowNode", len)?;
7357        if let Some(v) = self.state_table.as_ref() {
7358            struct_ser.serialize_field("stateTable", v)?;
7359        }
7360        if let Some(v) = self.mode.as_ref() {
7361            match v {
7362                now_node::Mode::UpdateCurrent(v) => {
7363                    struct_ser.serialize_field("updateCurrent", v)?;
7364                }
7365                now_node::Mode::GenerateSeries(v) => {
7366                    struct_ser.serialize_field("generateSeries", v)?;
7367                }
7368            }
7369        }
7370        struct_ser.end()
7371    }
7372}
7373impl<'de> serde::Deserialize<'de> for NowNode {
7374    #[allow(deprecated)]
7375    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7376    where
7377        D: serde::Deserializer<'de>,
7378    {
7379        const FIELDS: &[&str] = &[
7380            "state_table",
7381            "stateTable",
7382            "update_current",
7383            "updateCurrent",
7384            "generate_series",
7385            "generateSeries",
7386        ];
7387
7388        #[allow(clippy::enum_variant_names)]
7389        enum GeneratedField {
7390            StateTable,
7391            UpdateCurrent,
7392            GenerateSeries,
7393        }
7394        impl<'de> serde::Deserialize<'de> for GeneratedField {
7395            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7396            where
7397                D: serde::Deserializer<'de>,
7398            {
7399                struct GeneratedVisitor;
7400
7401                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7402                    type Value = GeneratedField;
7403
7404                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7405                        write!(formatter, "expected one of: {:?}", &FIELDS)
7406                    }
7407
7408                    #[allow(unused_variables)]
7409                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7410                    where
7411                        E: serde::de::Error,
7412                    {
7413                        match value {
7414                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7415                            "updateCurrent" | "update_current" => Ok(GeneratedField::UpdateCurrent),
7416                            "generateSeries" | "generate_series" => Ok(GeneratedField::GenerateSeries),
7417                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7418                        }
7419                    }
7420                }
7421                deserializer.deserialize_identifier(GeneratedVisitor)
7422            }
7423        }
7424        struct GeneratedVisitor;
7425        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7426            type Value = NowNode;
7427
7428            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7429                formatter.write_str("struct stream_plan.NowNode")
7430            }
7431
7432            fn visit_map<V>(self, mut map_: V) -> std::result::Result<NowNode, V::Error>
7433                where
7434                    V: serde::de::MapAccess<'de>,
7435            {
7436                let mut state_table__ = None;
7437                let mut mode__ = None;
7438                while let Some(k) = map_.next_key()? {
7439                    match k {
7440                        GeneratedField::StateTable => {
7441                            if state_table__.is_some() {
7442                                return Err(serde::de::Error::duplicate_field("stateTable"));
7443                            }
7444                            state_table__ = map_.next_value()?;
7445                        }
7446                        GeneratedField::UpdateCurrent => {
7447                            if mode__.is_some() {
7448                                return Err(serde::de::Error::duplicate_field("updateCurrent"));
7449                            }
7450                            mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::UpdateCurrent)
7451;
7452                        }
7453                        GeneratedField::GenerateSeries => {
7454                            if mode__.is_some() {
7455                                return Err(serde::de::Error::duplicate_field("generateSeries"));
7456                            }
7457                            mode__ = map_.next_value::<::std::option::Option<_>>()?.map(now_node::Mode::GenerateSeries)
7458;
7459                        }
7460                    }
7461                }
7462                Ok(NowNode {
7463                    state_table: state_table__,
7464                    mode: mode__,
7465                })
7466            }
7467        }
7468        deserializer.deserialize_struct("stream_plan.NowNode", FIELDS, GeneratedVisitor)
7469    }
7470}
7471impl serde::Serialize for OverWindowCachePolicy {
7472    #[allow(deprecated)]
7473    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7474    where
7475        S: serde::Serializer,
7476    {
7477        let variant = match self {
7478            Self::Unspecified => "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7479            Self::Full => "OVER_WINDOW_CACHE_POLICY_FULL",
7480            Self::Recent => "OVER_WINDOW_CACHE_POLICY_RECENT",
7481            Self::RecentFirstN => "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7482            Self::RecentLastN => "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7483        };
7484        serializer.serialize_str(variant)
7485    }
7486}
7487impl<'de> serde::Deserialize<'de> for OverWindowCachePolicy {
7488    #[allow(deprecated)]
7489    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7490    where
7491        D: serde::Deserializer<'de>,
7492    {
7493        const FIELDS: &[&str] = &[
7494            "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED",
7495            "OVER_WINDOW_CACHE_POLICY_FULL",
7496            "OVER_WINDOW_CACHE_POLICY_RECENT",
7497            "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N",
7498            "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N",
7499        ];
7500
7501        struct GeneratedVisitor;
7502
7503        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7504            type Value = OverWindowCachePolicy;
7505
7506            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7507                write!(formatter, "expected one of: {:?}", &FIELDS)
7508            }
7509
7510            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
7511            where
7512                E: serde::de::Error,
7513            {
7514                i32::try_from(v)
7515                    .ok()
7516                    .and_then(|x| x.try_into().ok())
7517                    .ok_or_else(|| {
7518                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
7519                    })
7520            }
7521
7522            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
7523            where
7524                E: serde::de::Error,
7525            {
7526                i32::try_from(v)
7527                    .ok()
7528                    .and_then(|x| x.try_into().ok())
7529                    .ok_or_else(|| {
7530                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
7531                    })
7532            }
7533
7534            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
7535            where
7536                E: serde::de::Error,
7537            {
7538                match value {
7539                    "OVER_WINDOW_CACHE_POLICY_UNSPECIFIED" => Ok(OverWindowCachePolicy::Unspecified),
7540                    "OVER_WINDOW_CACHE_POLICY_FULL" => Ok(OverWindowCachePolicy::Full),
7541                    "OVER_WINDOW_CACHE_POLICY_RECENT" => Ok(OverWindowCachePolicy::Recent),
7542                    "OVER_WINDOW_CACHE_POLICY_RECENT_FIRST_N" => Ok(OverWindowCachePolicy::RecentFirstN),
7543                    "OVER_WINDOW_CACHE_POLICY_RECENT_LAST_N" => Ok(OverWindowCachePolicy::RecentLastN),
7544                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
7545                }
7546            }
7547        }
7548        deserializer.deserialize_any(GeneratedVisitor)
7549    }
7550}
7551impl serde::Serialize for OverWindowNode {
7552    #[allow(deprecated)]
7553    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7554    where
7555        S: serde::Serializer,
7556    {
7557        use serde::ser::SerializeStruct;
7558        let mut len = 0;
7559        if !self.calls.is_empty() {
7560            len += 1;
7561        }
7562        if !self.partition_by.is_empty() {
7563            len += 1;
7564        }
7565        if !self.order_by.is_empty() {
7566            len += 1;
7567        }
7568        if self.state_table.is_some() {
7569            len += 1;
7570        }
7571        if self.cache_policy != 0 {
7572            len += 1;
7573        }
7574        let mut struct_ser = serializer.serialize_struct("stream_plan.OverWindowNode", len)?;
7575        if !self.calls.is_empty() {
7576            struct_ser.serialize_field("calls", &self.calls)?;
7577        }
7578        if !self.partition_by.is_empty() {
7579            struct_ser.serialize_field("partitionBy", &self.partition_by)?;
7580        }
7581        if !self.order_by.is_empty() {
7582            struct_ser.serialize_field("orderBy", &self.order_by)?;
7583        }
7584        if let Some(v) = self.state_table.as_ref() {
7585            struct_ser.serialize_field("stateTable", v)?;
7586        }
7587        if self.cache_policy != 0 {
7588            let v = OverWindowCachePolicy::try_from(self.cache_policy)
7589                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.cache_policy)))?;
7590            struct_ser.serialize_field("cachePolicy", &v)?;
7591        }
7592        struct_ser.end()
7593    }
7594}
7595impl<'de> serde::Deserialize<'de> for OverWindowNode {
7596    #[allow(deprecated)]
7597    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7598    where
7599        D: serde::Deserializer<'de>,
7600    {
7601        const FIELDS: &[&str] = &[
7602            "calls",
7603            "partition_by",
7604            "partitionBy",
7605            "order_by",
7606            "orderBy",
7607            "state_table",
7608            "stateTable",
7609            "cache_policy",
7610            "cachePolicy",
7611        ];
7612
7613        #[allow(clippy::enum_variant_names)]
7614        enum GeneratedField {
7615            Calls,
7616            PartitionBy,
7617            OrderBy,
7618            StateTable,
7619            CachePolicy,
7620        }
7621        impl<'de> serde::Deserialize<'de> for GeneratedField {
7622            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7623            where
7624                D: serde::Deserializer<'de>,
7625            {
7626                struct GeneratedVisitor;
7627
7628                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7629                    type Value = GeneratedField;
7630
7631                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7632                        write!(formatter, "expected one of: {:?}", &FIELDS)
7633                    }
7634
7635                    #[allow(unused_variables)]
7636                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7637                    where
7638                        E: serde::de::Error,
7639                    {
7640                        match value {
7641                            "calls" => Ok(GeneratedField::Calls),
7642                            "partitionBy" | "partition_by" => Ok(GeneratedField::PartitionBy),
7643                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
7644                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
7645                            "cachePolicy" | "cache_policy" => Ok(GeneratedField::CachePolicy),
7646                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7647                        }
7648                    }
7649                }
7650                deserializer.deserialize_identifier(GeneratedVisitor)
7651            }
7652        }
7653        struct GeneratedVisitor;
7654        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7655            type Value = OverWindowNode;
7656
7657            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7658                formatter.write_str("struct stream_plan.OverWindowNode")
7659            }
7660
7661            fn visit_map<V>(self, mut map_: V) -> std::result::Result<OverWindowNode, V::Error>
7662                where
7663                    V: serde::de::MapAccess<'de>,
7664            {
7665                let mut calls__ = None;
7666                let mut partition_by__ = None;
7667                let mut order_by__ = None;
7668                let mut state_table__ = None;
7669                let mut cache_policy__ = None;
7670                while let Some(k) = map_.next_key()? {
7671                    match k {
7672                        GeneratedField::Calls => {
7673                            if calls__.is_some() {
7674                                return Err(serde::de::Error::duplicate_field("calls"));
7675                            }
7676                            calls__ = Some(map_.next_value()?);
7677                        }
7678                        GeneratedField::PartitionBy => {
7679                            if partition_by__.is_some() {
7680                                return Err(serde::de::Error::duplicate_field("partitionBy"));
7681                            }
7682                            partition_by__ = 
7683                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7684                                    .into_iter().map(|x| x.0).collect())
7685                            ;
7686                        }
7687                        GeneratedField::OrderBy => {
7688                            if order_by__.is_some() {
7689                                return Err(serde::de::Error::duplicate_field("orderBy"));
7690                            }
7691                            order_by__ = Some(map_.next_value()?);
7692                        }
7693                        GeneratedField::StateTable => {
7694                            if state_table__.is_some() {
7695                                return Err(serde::de::Error::duplicate_field("stateTable"));
7696                            }
7697                            state_table__ = map_.next_value()?;
7698                        }
7699                        GeneratedField::CachePolicy => {
7700                            if cache_policy__.is_some() {
7701                                return Err(serde::de::Error::duplicate_field("cachePolicy"));
7702                            }
7703                            cache_policy__ = Some(map_.next_value::<OverWindowCachePolicy>()? as i32);
7704                        }
7705                    }
7706                }
7707                Ok(OverWindowNode {
7708                    calls: calls__.unwrap_or_default(),
7709                    partition_by: partition_by__.unwrap_or_default(),
7710                    order_by: order_by__.unwrap_or_default(),
7711                    state_table: state_table__,
7712                    cache_policy: cache_policy__.unwrap_or_default(),
7713                })
7714            }
7715        }
7716        deserializer.deserialize_struct("stream_plan.OverWindowNode", FIELDS, GeneratedVisitor)
7717    }
7718}
7719impl serde::Serialize for PauseMutation {
7720    #[allow(deprecated)]
7721    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7722    where
7723        S: serde::Serializer,
7724    {
7725        use serde::ser::SerializeStruct;
7726        let len = 0;
7727        let struct_ser = serializer.serialize_struct("stream_plan.PauseMutation", len)?;
7728        struct_ser.end()
7729    }
7730}
7731impl<'de> serde::Deserialize<'de> for PauseMutation {
7732    #[allow(deprecated)]
7733    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7734    where
7735        D: serde::Deserializer<'de>,
7736    {
7737        const FIELDS: &[&str] = &[
7738        ];
7739
7740        #[allow(clippy::enum_variant_names)]
7741        enum GeneratedField {
7742        }
7743        impl<'de> serde::Deserialize<'de> for GeneratedField {
7744            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7745            where
7746                D: serde::Deserializer<'de>,
7747            {
7748                struct GeneratedVisitor;
7749
7750                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7751                    type Value = GeneratedField;
7752
7753                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7754                        write!(formatter, "expected one of: {:?}", &FIELDS)
7755                    }
7756
7757                    #[allow(unused_variables)]
7758                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7759                    where
7760                        E: serde::de::Error,
7761                    {
7762                            Err(serde::de::Error::unknown_field(value, FIELDS))
7763                    }
7764                }
7765                deserializer.deserialize_identifier(GeneratedVisitor)
7766            }
7767        }
7768        struct GeneratedVisitor;
7769        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7770            type Value = PauseMutation;
7771
7772            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7773                formatter.write_str("struct stream_plan.PauseMutation")
7774            }
7775
7776            fn visit_map<V>(self, mut map_: V) -> std::result::Result<PauseMutation, V::Error>
7777                where
7778                    V: serde::de::MapAccess<'de>,
7779            {
7780                while map_.next_key::<GeneratedField>()?.is_some() {
7781                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
7782                }
7783                Ok(PauseMutation {
7784                })
7785            }
7786        }
7787        deserializer.deserialize_struct("stream_plan.PauseMutation", FIELDS, GeneratedVisitor)
7788    }
7789}
7790impl serde::Serialize for ProjectNode {
7791    #[allow(deprecated)]
7792    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7793    where
7794        S: serde::Serializer,
7795    {
7796        use serde::ser::SerializeStruct;
7797        let mut len = 0;
7798        if !self.select_list.is_empty() {
7799            len += 1;
7800        }
7801        if !self.watermark_input_cols.is_empty() {
7802            len += 1;
7803        }
7804        if !self.watermark_output_cols.is_empty() {
7805            len += 1;
7806        }
7807        if !self.nondecreasing_exprs.is_empty() {
7808            len += 1;
7809        }
7810        if self.noop_update_hint {
7811            len += 1;
7812        }
7813        let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectNode", len)?;
7814        if !self.select_list.is_empty() {
7815            struct_ser.serialize_field("selectList", &self.select_list)?;
7816        }
7817        if !self.watermark_input_cols.is_empty() {
7818            struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
7819        }
7820        if !self.watermark_output_cols.is_empty() {
7821            struct_ser.serialize_field("watermarkOutputCols", &self.watermark_output_cols)?;
7822        }
7823        if !self.nondecreasing_exprs.is_empty() {
7824            struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
7825        }
7826        if self.noop_update_hint {
7827            struct_ser.serialize_field("noopUpdateHint", &self.noop_update_hint)?;
7828        }
7829        struct_ser.end()
7830    }
7831}
7832impl<'de> serde::Deserialize<'de> for ProjectNode {
7833    #[allow(deprecated)]
7834    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
7835    where
7836        D: serde::Deserializer<'de>,
7837    {
7838        const FIELDS: &[&str] = &[
7839            "select_list",
7840            "selectList",
7841            "watermark_input_cols",
7842            "watermarkInputCols",
7843            "watermark_output_cols",
7844            "watermarkOutputCols",
7845            "nondecreasing_exprs",
7846            "nondecreasingExprs",
7847            "noop_update_hint",
7848            "noopUpdateHint",
7849        ];
7850
7851        #[allow(clippy::enum_variant_names)]
7852        enum GeneratedField {
7853            SelectList,
7854            WatermarkInputCols,
7855            WatermarkOutputCols,
7856            NondecreasingExprs,
7857            NoopUpdateHint,
7858        }
7859        impl<'de> serde::Deserialize<'de> for GeneratedField {
7860            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
7861            where
7862                D: serde::Deserializer<'de>,
7863            {
7864                struct GeneratedVisitor;
7865
7866                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7867                    type Value = GeneratedField;
7868
7869                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7870                        write!(formatter, "expected one of: {:?}", &FIELDS)
7871                    }
7872
7873                    #[allow(unused_variables)]
7874                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
7875                    where
7876                        E: serde::de::Error,
7877                    {
7878                        match value {
7879                            "selectList" | "select_list" => Ok(GeneratedField::SelectList),
7880                            "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
7881                            "watermarkOutputCols" | "watermark_output_cols" => Ok(GeneratedField::WatermarkOutputCols),
7882                            "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
7883                            "noopUpdateHint" | "noop_update_hint" => Ok(GeneratedField::NoopUpdateHint),
7884                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
7885                        }
7886                    }
7887                }
7888                deserializer.deserialize_identifier(GeneratedVisitor)
7889            }
7890        }
7891        struct GeneratedVisitor;
7892        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
7893            type Value = ProjectNode;
7894
7895            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7896                formatter.write_str("struct stream_plan.ProjectNode")
7897            }
7898
7899            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectNode, V::Error>
7900                where
7901                    V: serde::de::MapAccess<'de>,
7902            {
7903                let mut select_list__ = None;
7904                let mut watermark_input_cols__ = None;
7905                let mut watermark_output_cols__ = None;
7906                let mut nondecreasing_exprs__ = None;
7907                let mut noop_update_hint__ = None;
7908                while let Some(k) = map_.next_key()? {
7909                    match k {
7910                        GeneratedField::SelectList => {
7911                            if select_list__.is_some() {
7912                                return Err(serde::de::Error::duplicate_field("selectList"));
7913                            }
7914                            select_list__ = Some(map_.next_value()?);
7915                        }
7916                        GeneratedField::WatermarkInputCols => {
7917                            if watermark_input_cols__.is_some() {
7918                                return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
7919                            }
7920                            watermark_input_cols__ = 
7921                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7922                                    .into_iter().map(|x| x.0).collect())
7923                            ;
7924                        }
7925                        GeneratedField::WatermarkOutputCols => {
7926                            if watermark_output_cols__.is_some() {
7927                                return Err(serde::de::Error::duplicate_field("watermarkOutputCols"));
7928                            }
7929                            watermark_output_cols__ = 
7930                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7931                                    .into_iter().map(|x| x.0).collect())
7932                            ;
7933                        }
7934                        GeneratedField::NondecreasingExprs => {
7935                            if nondecreasing_exprs__.is_some() {
7936                                return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
7937                            }
7938                            nondecreasing_exprs__ = 
7939                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
7940                                    .into_iter().map(|x| x.0).collect())
7941                            ;
7942                        }
7943                        GeneratedField::NoopUpdateHint => {
7944                            if noop_update_hint__.is_some() {
7945                                return Err(serde::de::Error::duplicate_field("noopUpdateHint"));
7946                            }
7947                            noop_update_hint__ = Some(map_.next_value()?);
7948                        }
7949                    }
7950                }
7951                Ok(ProjectNode {
7952                    select_list: select_list__.unwrap_or_default(),
7953                    watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
7954                    watermark_output_cols: watermark_output_cols__.unwrap_or_default(),
7955                    nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
7956                    noop_update_hint: noop_update_hint__.unwrap_or_default(),
7957                })
7958            }
7959        }
7960        deserializer.deserialize_struct("stream_plan.ProjectNode", FIELDS, GeneratedVisitor)
7961    }
7962}
7963impl serde::Serialize for ProjectSetNode {
7964    #[allow(deprecated)]
7965    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
7966    where
7967        S: serde::Serializer,
7968    {
7969        use serde::ser::SerializeStruct;
7970        let mut len = 0;
7971        if !self.select_list.is_empty() {
7972            len += 1;
7973        }
7974        if !self.watermark_input_cols.is_empty() {
7975            len += 1;
7976        }
7977        if !self.watermark_expr_indices.is_empty() {
7978            len += 1;
7979        }
7980        if !self.nondecreasing_exprs.is_empty() {
7981            len += 1;
7982        }
7983        let mut struct_ser = serializer.serialize_struct("stream_plan.ProjectSetNode", len)?;
7984        if !self.select_list.is_empty() {
7985            struct_ser.serialize_field("selectList", &self.select_list)?;
7986        }
7987        if !self.watermark_input_cols.is_empty() {
7988            struct_ser.serialize_field("watermarkInputCols", &self.watermark_input_cols)?;
7989        }
7990        if !self.watermark_expr_indices.is_empty() {
7991            struct_ser.serialize_field("watermarkExprIndices", &self.watermark_expr_indices)?;
7992        }
7993        if !self.nondecreasing_exprs.is_empty() {
7994            struct_ser.serialize_field("nondecreasingExprs", &self.nondecreasing_exprs)?;
7995        }
7996        struct_ser.end()
7997    }
7998}
7999impl<'de> serde::Deserialize<'de> for ProjectSetNode {
8000    #[allow(deprecated)]
8001    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8002    where
8003        D: serde::Deserializer<'de>,
8004    {
8005        const FIELDS: &[&str] = &[
8006            "select_list",
8007            "selectList",
8008            "watermark_input_cols",
8009            "watermarkInputCols",
8010            "watermark_expr_indices",
8011            "watermarkExprIndices",
8012            "nondecreasing_exprs",
8013            "nondecreasingExprs",
8014        ];
8015
8016        #[allow(clippy::enum_variant_names)]
8017        enum GeneratedField {
8018            SelectList,
8019            WatermarkInputCols,
8020            WatermarkExprIndices,
8021            NondecreasingExprs,
8022        }
8023        impl<'de> serde::Deserialize<'de> for GeneratedField {
8024            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8025            where
8026                D: serde::Deserializer<'de>,
8027            {
8028                struct GeneratedVisitor;
8029
8030                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8031                    type Value = GeneratedField;
8032
8033                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8034                        write!(formatter, "expected one of: {:?}", &FIELDS)
8035                    }
8036
8037                    #[allow(unused_variables)]
8038                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8039                    where
8040                        E: serde::de::Error,
8041                    {
8042                        match value {
8043                            "selectList" | "select_list" => Ok(GeneratedField::SelectList),
8044                            "watermarkInputCols" | "watermark_input_cols" => Ok(GeneratedField::WatermarkInputCols),
8045                            "watermarkExprIndices" | "watermark_expr_indices" => Ok(GeneratedField::WatermarkExprIndices),
8046                            "nondecreasingExprs" | "nondecreasing_exprs" => Ok(GeneratedField::NondecreasingExprs),
8047                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8048                        }
8049                    }
8050                }
8051                deserializer.deserialize_identifier(GeneratedVisitor)
8052            }
8053        }
8054        struct GeneratedVisitor;
8055        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8056            type Value = ProjectSetNode;
8057
8058            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8059                formatter.write_str("struct stream_plan.ProjectSetNode")
8060            }
8061
8062            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ProjectSetNode, V::Error>
8063                where
8064                    V: serde::de::MapAccess<'de>,
8065            {
8066                let mut select_list__ = None;
8067                let mut watermark_input_cols__ = None;
8068                let mut watermark_expr_indices__ = None;
8069                let mut nondecreasing_exprs__ = None;
8070                while let Some(k) = map_.next_key()? {
8071                    match k {
8072                        GeneratedField::SelectList => {
8073                            if select_list__.is_some() {
8074                                return Err(serde::de::Error::duplicate_field("selectList"));
8075                            }
8076                            select_list__ = Some(map_.next_value()?);
8077                        }
8078                        GeneratedField::WatermarkInputCols => {
8079                            if watermark_input_cols__.is_some() {
8080                                return Err(serde::de::Error::duplicate_field("watermarkInputCols"));
8081                            }
8082                            watermark_input_cols__ = 
8083                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8084                                    .into_iter().map(|x| x.0).collect())
8085                            ;
8086                        }
8087                        GeneratedField::WatermarkExprIndices => {
8088                            if watermark_expr_indices__.is_some() {
8089                                return Err(serde::de::Error::duplicate_field("watermarkExprIndices"));
8090                            }
8091                            watermark_expr_indices__ = 
8092                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8093                                    .into_iter().map(|x| x.0).collect())
8094                            ;
8095                        }
8096                        GeneratedField::NondecreasingExprs => {
8097                            if nondecreasing_exprs__.is_some() {
8098                                return Err(serde::de::Error::duplicate_field("nondecreasingExprs"));
8099                            }
8100                            nondecreasing_exprs__ = 
8101                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
8102                                    .into_iter().map(|x| x.0).collect())
8103                            ;
8104                        }
8105                    }
8106                }
8107                Ok(ProjectSetNode {
8108                    select_list: select_list__.unwrap_or_default(),
8109                    watermark_input_cols: watermark_input_cols__.unwrap_or_default(),
8110                    watermark_expr_indices: watermark_expr_indices__.unwrap_or_default(),
8111                    nondecreasing_exprs: nondecreasing_exprs__.unwrap_or_default(),
8112                })
8113            }
8114        }
8115        deserializer.deserialize_struct("stream_plan.ProjectSetNode", FIELDS, GeneratedVisitor)
8116    }
8117}
8118impl serde::Serialize for RefreshStartMutation {
8119    #[allow(deprecated)]
8120    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8121    where
8122        S: serde::Serializer,
8123    {
8124        use serde::ser::SerializeStruct;
8125        let mut len = 0;
8126        if self.table_id != 0 {
8127            len += 1;
8128        }
8129        if self.associated_source_id != 0 {
8130            len += 1;
8131        }
8132        let mut struct_ser = serializer.serialize_struct("stream_plan.RefreshStartMutation", len)?;
8133        if self.table_id != 0 {
8134            struct_ser.serialize_field("tableId", &self.table_id)?;
8135        }
8136        if self.associated_source_id != 0 {
8137            struct_ser.serialize_field("associatedSourceId", &self.associated_source_id)?;
8138        }
8139        struct_ser.end()
8140    }
8141}
8142impl<'de> serde::Deserialize<'de> for RefreshStartMutation {
8143    #[allow(deprecated)]
8144    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8145    where
8146        D: serde::Deserializer<'de>,
8147    {
8148        const FIELDS: &[&str] = &[
8149            "table_id",
8150            "tableId",
8151            "associated_source_id",
8152            "associatedSourceId",
8153        ];
8154
8155        #[allow(clippy::enum_variant_names)]
8156        enum GeneratedField {
8157            TableId,
8158            AssociatedSourceId,
8159        }
8160        impl<'de> serde::Deserialize<'de> for GeneratedField {
8161            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8162            where
8163                D: serde::Deserializer<'de>,
8164            {
8165                struct GeneratedVisitor;
8166
8167                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8168                    type Value = GeneratedField;
8169
8170                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8171                        write!(formatter, "expected one of: {:?}", &FIELDS)
8172                    }
8173
8174                    #[allow(unused_variables)]
8175                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8176                    where
8177                        E: serde::de::Error,
8178                    {
8179                        match value {
8180                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
8181                            "associatedSourceId" | "associated_source_id" => Ok(GeneratedField::AssociatedSourceId),
8182                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8183                        }
8184                    }
8185                }
8186                deserializer.deserialize_identifier(GeneratedVisitor)
8187            }
8188        }
8189        struct GeneratedVisitor;
8190        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8191            type Value = RefreshStartMutation;
8192
8193            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8194                formatter.write_str("struct stream_plan.RefreshStartMutation")
8195            }
8196
8197            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RefreshStartMutation, V::Error>
8198                where
8199                    V: serde::de::MapAccess<'de>,
8200            {
8201                let mut table_id__ = None;
8202                let mut associated_source_id__ = None;
8203                while let Some(k) = map_.next_key()? {
8204                    match k {
8205                        GeneratedField::TableId => {
8206                            if table_id__.is_some() {
8207                                return Err(serde::de::Error::duplicate_field("tableId"));
8208                            }
8209                            table_id__ = 
8210                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8211                            ;
8212                        }
8213                        GeneratedField::AssociatedSourceId => {
8214                            if associated_source_id__.is_some() {
8215                                return Err(serde::de::Error::duplicate_field("associatedSourceId"));
8216                            }
8217                            associated_source_id__ = 
8218                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8219                            ;
8220                        }
8221                    }
8222                }
8223                Ok(RefreshStartMutation {
8224                    table_id: table_id__.unwrap_or_default(),
8225                    associated_source_id: associated_source_id__.unwrap_or_default(),
8226                })
8227            }
8228        }
8229        deserializer.deserialize_struct("stream_plan.RefreshStartMutation", FIELDS, GeneratedVisitor)
8230    }
8231}
8232impl serde::Serialize for ResumeMutation {
8233    #[allow(deprecated)]
8234    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8235    where
8236        S: serde::Serializer,
8237    {
8238        use serde::ser::SerializeStruct;
8239        let len = 0;
8240        let struct_ser = serializer.serialize_struct("stream_plan.ResumeMutation", len)?;
8241        struct_ser.end()
8242    }
8243}
8244impl<'de> serde::Deserialize<'de> for ResumeMutation {
8245    #[allow(deprecated)]
8246    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8247    where
8248        D: serde::Deserializer<'de>,
8249    {
8250        const FIELDS: &[&str] = &[
8251        ];
8252
8253        #[allow(clippy::enum_variant_names)]
8254        enum GeneratedField {
8255        }
8256        impl<'de> serde::Deserialize<'de> for GeneratedField {
8257            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8258            where
8259                D: serde::Deserializer<'de>,
8260            {
8261                struct GeneratedVisitor;
8262
8263                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8264                    type Value = GeneratedField;
8265
8266                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8267                        write!(formatter, "expected one of: {:?}", &FIELDS)
8268                    }
8269
8270                    #[allow(unused_variables)]
8271                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8272                    where
8273                        E: serde::de::Error,
8274                    {
8275                            Err(serde::de::Error::unknown_field(value, FIELDS))
8276                    }
8277                }
8278                deserializer.deserialize_identifier(GeneratedVisitor)
8279            }
8280        }
8281        struct GeneratedVisitor;
8282        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8283            type Value = ResumeMutation;
8284
8285            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8286                formatter.write_str("struct stream_plan.ResumeMutation")
8287            }
8288
8289            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ResumeMutation, V::Error>
8290                where
8291                    V: serde::de::MapAccess<'de>,
8292            {
8293                while map_.next_key::<GeneratedField>()?.is_some() {
8294                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
8295                }
8296                Ok(ResumeMutation {
8297                })
8298            }
8299        }
8300        deserializer.deserialize_struct("stream_plan.ResumeMutation", FIELDS, GeneratedVisitor)
8301    }
8302}
8303impl serde::Serialize for RowIdGenNode {
8304    #[allow(deprecated)]
8305    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8306    where
8307        S: serde::Serializer,
8308    {
8309        use serde::ser::SerializeStruct;
8310        let mut len = 0;
8311        if self.row_id_index != 0 {
8312            len += 1;
8313        }
8314        let mut struct_ser = serializer.serialize_struct("stream_plan.RowIdGenNode", len)?;
8315        if self.row_id_index != 0 {
8316            #[allow(clippy::needless_borrow)]
8317            #[allow(clippy::needless_borrows_for_generic_args)]
8318            struct_ser.serialize_field("rowIdIndex", ToString::to_string(&self.row_id_index).as_str())?;
8319        }
8320        struct_ser.end()
8321    }
8322}
8323impl<'de> serde::Deserialize<'de> for RowIdGenNode {
8324    #[allow(deprecated)]
8325    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8326    where
8327        D: serde::Deserializer<'de>,
8328    {
8329        const FIELDS: &[&str] = &[
8330            "row_id_index",
8331            "rowIdIndex",
8332        ];
8333
8334        #[allow(clippy::enum_variant_names)]
8335        enum GeneratedField {
8336            RowIdIndex,
8337        }
8338        impl<'de> serde::Deserialize<'de> for GeneratedField {
8339            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8340            where
8341                D: serde::Deserializer<'de>,
8342            {
8343                struct GeneratedVisitor;
8344
8345                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8346                    type Value = GeneratedField;
8347
8348                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8349                        write!(formatter, "expected one of: {:?}", &FIELDS)
8350                    }
8351
8352                    #[allow(unused_variables)]
8353                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8354                    where
8355                        E: serde::de::Error,
8356                    {
8357                        match value {
8358                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
8359                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8360                        }
8361                    }
8362                }
8363                deserializer.deserialize_identifier(GeneratedVisitor)
8364            }
8365        }
8366        struct GeneratedVisitor;
8367        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8368            type Value = RowIdGenNode;
8369
8370            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8371                formatter.write_str("struct stream_plan.RowIdGenNode")
8372            }
8373
8374            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowIdGenNode, V::Error>
8375                where
8376                    V: serde::de::MapAccess<'de>,
8377            {
8378                let mut row_id_index__ = None;
8379                while let Some(k) = map_.next_key()? {
8380                    match k {
8381                        GeneratedField::RowIdIndex => {
8382                            if row_id_index__.is_some() {
8383                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
8384                            }
8385                            row_id_index__ = 
8386                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8387                            ;
8388                        }
8389                    }
8390                }
8391                Ok(RowIdGenNode {
8392                    row_id_index: row_id_index__.unwrap_or_default(),
8393                })
8394            }
8395        }
8396        deserializer.deserialize_struct("stream_plan.RowIdGenNode", FIELDS, GeneratedVisitor)
8397    }
8398}
8399impl serde::Serialize for RowMergeNode {
8400    #[allow(deprecated)]
8401    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8402    where
8403        S: serde::Serializer,
8404    {
8405        use serde::ser::SerializeStruct;
8406        let mut len = 0;
8407        if self.lhs_mapping.is_some() {
8408            len += 1;
8409        }
8410        if self.rhs_mapping.is_some() {
8411            len += 1;
8412        }
8413        let mut struct_ser = serializer.serialize_struct("stream_plan.RowMergeNode", len)?;
8414        if let Some(v) = self.lhs_mapping.as_ref() {
8415            struct_ser.serialize_field("lhsMapping", v)?;
8416        }
8417        if let Some(v) = self.rhs_mapping.as_ref() {
8418            struct_ser.serialize_field("rhsMapping", v)?;
8419        }
8420        struct_ser.end()
8421    }
8422}
8423impl<'de> serde::Deserialize<'de> for RowMergeNode {
8424    #[allow(deprecated)]
8425    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8426    where
8427        D: serde::Deserializer<'de>,
8428    {
8429        const FIELDS: &[&str] = &[
8430            "lhs_mapping",
8431            "lhsMapping",
8432            "rhs_mapping",
8433            "rhsMapping",
8434        ];
8435
8436        #[allow(clippy::enum_variant_names)]
8437        enum GeneratedField {
8438            LhsMapping,
8439            RhsMapping,
8440        }
8441        impl<'de> serde::Deserialize<'de> for GeneratedField {
8442            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8443            where
8444                D: serde::Deserializer<'de>,
8445            {
8446                struct GeneratedVisitor;
8447
8448                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8449                    type Value = GeneratedField;
8450
8451                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8452                        write!(formatter, "expected one of: {:?}", &FIELDS)
8453                    }
8454
8455                    #[allow(unused_variables)]
8456                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8457                    where
8458                        E: serde::de::Error,
8459                    {
8460                        match value {
8461                            "lhsMapping" | "lhs_mapping" => Ok(GeneratedField::LhsMapping),
8462                            "rhsMapping" | "rhs_mapping" => Ok(GeneratedField::RhsMapping),
8463                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8464                        }
8465                    }
8466                }
8467                deserializer.deserialize_identifier(GeneratedVisitor)
8468            }
8469        }
8470        struct GeneratedVisitor;
8471        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8472            type Value = RowMergeNode;
8473
8474            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8475                formatter.write_str("struct stream_plan.RowMergeNode")
8476            }
8477
8478            fn visit_map<V>(self, mut map_: V) -> std::result::Result<RowMergeNode, V::Error>
8479                where
8480                    V: serde::de::MapAccess<'de>,
8481            {
8482                let mut lhs_mapping__ = None;
8483                let mut rhs_mapping__ = None;
8484                while let Some(k) = map_.next_key()? {
8485                    match k {
8486                        GeneratedField::LhsMapping => {
8487                            if lhs_mapping__.is_some() {
8488                                return Err(serde::de::Error::duplicate_field("lhsMapping"));
8489                            }
8490                            lhs_mapping__ = map_.next_value()?;
8491                        }
8492                        GeneratedField::RhsMapping => {
8493                            if rhs_mapping__.is_some() {
8494                                return Err(serde::de::Error::duplicate_field("rhsMapping"));
8495                            }
8496                            rhs_mapping__ = map_.next_value()?;
8497                        }
8498                    }
8499                }
8500                Ok(RowMergeNode {
8501                    lhs_mapping: lhs_mapping__,
8502                    rhs_mapping: rhs_mapping__,
8503                })
8504            }
8505        }
8506        deserializer.deserialize_struct("stream_plan.RowMergeNode", FIELDS, GeneratedVisitor)
8507    }
8508}
8509impl serde::Serialize for SimpleAggNode {
8510    #[allow(deprecated)]
8511    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8512    where
8513        S: serde::Serializer,
8514    {
8515        use serde::ser::SerializeStruct;
8516        let mut len = 0;
8517        if !self.agg_calls.is_empty() {
8518            len += 1;
8519        }
8520        if !self.agg_call_states.is_empty() {
8521            len += 1;
8522        }
8523        if self.intermediate_state_table.is_some() {
8524            len += 1;
8525        }
8526        if self.is_append_only {
8527            len += 1;
8528        }
8529        if !self.distinct_dedup_tables.is_empty() {
8530            len += 1;
8531        }
8532        if self.row_count_index != 0 {
8533            len += 1;
8534        }
8535        if self.version != 0 {
8536            len += 1;
8537        }
8538        if self.must_output_per_barrier {
8539            len += 1;
8540        }
8541        let mut struct_ser = serializer.serialize_struct("stream_plan.SimpleAggNode", len)?;
8542        if !self.agg_calls.is_empty() {
8543            struct_ser.serialize_field("aggCalls", &self.agg_calls)?;
8544        }
8545        if !self.agg_call_states.is_empty() {
8546            struct_ser.serialize_field("aggCallStates", &self.agg_call_states)?;
8547        }
8548        if let Some(v) = self.intermediate_state_table.as_ref() {
8549            struct_ser.serialize_field("intermediateStateTable", v)?;
8550        }
8551        if self.is_append_only {
8552            struct_ser.serialize_field("isAppendOnly", &self.is_append_only)?;
8553        }
8554        if !self.distinct_dedup_tables.is_empty() {
8555            struct_ser.serialize_field("distinctDedupTables", &self.distinct_dedup_tables)?;
8556        }
8557        if self.row_count_index != 0 {
8558            struct_ser.serialize_field("rowCountIndex", &self.row_count_index)?;
8559        }
8560        if self.version != 0 {
8561            let v = AggNodeVersion::try_from(self.version)
8562                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.version)))?;
8563            struct_ser.serialize_field("version", &v)?;
8564        }
8565        if self.must_output_per_barrier {
8566            struct_ser.serialize_field("mustOutputPerBarrier", &self.must_output_per_barrier)?;
8567        }
8568        struct_ser.end()
8569    }
8570}
8571impl<'de> serde::Deserialize<'de> for SimpleAggNode {
8572    #[allow(deprecated)]
8573    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8574    where
8575        D: serde::Deserializer<'de>,
8576    {
8577        const FIELDS: &[&str] = &[
8578            "agg_calls",
8579            "aggCalls",
8580            "agg_call_states",
8581            "aggCallStates",
8582            "intermediate_state_table",
8583            "intermediateStateTable",
8584            "is_append_only",
8585            "isAppendOnly",
8586            "distinct_dedup_tables",
8587            "distinctDedupTables",
8588            "row_count_index",
8589            "rowCountIndex",
8590            "version",
8591            "must_output_per_barrier",
8592            "mustOutputPerBarrier",
8593        ];
8594
8595        #[allow(clippy::enum_variant_names)]
8596        enum GeneratedField {
8597            AggCalls,
8598            AggCallStates,
8599            IntermediateStateTable,
8600            IsAppendOnly,
8601            DistinctDedupTables,
8602            RowCountIndex,
8603            Version,
8604            MustOutputPerBarrier,
8605        }
8606        impl<'de> serde::Deserialize<'de> for GeneratedField {
8607            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8608            where
8609                D: serde::Deserializer<'de>,
8610            {
8611                struct GeneratedVisitor;
8612
8613                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8614                    type Value = GeneratedField;
8615
8616                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8617                        write!(formatter, "expected one of: {:?}", &FIELDS)
8618                    }
8619
8620                    #[allow(unused_variables)]
8621                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8622                    where
8623                        E: serde::de::Error,
8624                    {
8625                        match value {
8626                            "aggCalls" | "agg_calls" => Ok(GeneratedField::AggCalls),
8627                            "aggCallStates" | "agg_call_states" => Ok(GeneratedField::AggCallStates),
8628                            "intermediateStateTable" | "intermediate_state_table" => Ok(GeneratedField::IntermediateStateTable),
8629                            "isAppendOnly" | "is_append_only" => Ok(GeneratedField::IsAppendOnly),
8630                            "distinctDedupTables" | "distinct_dedup_tables" => Ok(GeneratedField::DistinctDedupTables),
8631                            "rowCountIndex" | "row_count_index" => Ok(GeneratedField::RowCountIndex),
8632                            "version" => Ok(GeneratedField::Version),
8633                            "mustOutputPerBarrier" | "must_output_per_barrier" => Ok(GeneratedField::MustOutputPerBarrier),
8634                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8635                        }
8636                    }
8637                }
8638                deserializer.deserialize_identifier(GeneratedVisitor)
8639            }
8640        }
8641        struct GeneratedVisitor;
8642        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8643            type Value = SimpleAggNode;
8644
8645            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8646                formatter.write_str("struct stream_plan.SimpleAggNode")
8647            }
8648
8649            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SimpleAggNode, V::Error>
8650                where
8651                    V: serde::de::MapAccess<'de>,
8652            {
8653                let mut agg_calls__ = None;
8654                let mut agg_call_states__ = None;
8655                let mut intermediate_state_table__ = None;
8656                let mut is_append_only__ = None;
8657                let mut distinct_dedup_tables__ = None;
8658                let mut row_count_index__ = None;
8659                let mut version__ = None;
8660                let mut must_output_per_barrier__ = None;
8661                while let Some(k) = map_.next_key()? {
8662                    match k {
8663                        GeneratedField::AggCalls => {
8664                            if agg_calls__.is_some() {
8665                                return Err(serde::de::Error::duplicate_field("aggCalls"));
8666                            }
8667                            agg_calls__ = Some(map_.next_value()?);
8668                        }
8669                        GeneratedField::AggCallStates => {
8670                            if agg_call_states__.is_some() {
8671                                return Err(serde::de::Error::duplicate_field("aggCallStates"));
8672                            }
8673                            agg_call_states__ = Some(map_.next_value()?);
8674                        }
8675                        GeneratedField::IntermediateStateTable => {
8676                            if intermediate_state_table__.is_some() {
8677                                return Err(serde::de::Error::duplicate_field("intermediateStateTable"));
8678                            }
8679                            intermediate_state_table__ = map_.next_value()?;
8680                        }
8681                        GeneratedField::IsAppendOnly => {
8682                            if is_append_only__.is_some() {
8683                                return Err(serde::de::Error::duplicate_field("isAppendOnly"));
8684                            }
8685                            is_append_only__ = Some(map_.next_value()?);
8686                        }
8687                        GeneratedField::DistinctDedupTables => {
8688                            if distinct_dedup_tables__.is_some() {
8689                                return Err(serde::de::Error::duplicate_field("distinctDedupTables"));
8690                            }
8691                            distinct_dedup_tables__ = Some(
8692                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
8693                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
8694                            );
8695                        }
8696                        GeneratedField::RowCountIndex => {
8697                            if row_count_index__.is_some() {
8698                                return Err(serde::de::Error::duplicate_field("rowCountIndex"));
8699                            }
8700                            row_count_index__ = 
8701                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
8702                            ;
8703                        }
8704                        GeneratedField::Version => {
8705                            if version__.is_some() {
8706                                return Err(serde::de::Error::duplicate_field("version"));
8707                            }
8708                            version__ = Some(map_.next_value::<AggNodeVersion>()? as i32);
8709                        }
8710                        GeneratedField::MustOutputPerBarrier => {
8711                            if must_output_per_barrier__.is_some() {
8712                                return Err(serde::de::Error::duplicate_field("mustOutputPerBarrier"));
8713                            }
8714                            must_output_per_barrier__ = Some(map_.next_value()?);
8715                        }
8716                    }
8717                }
8718                Ok(SimpleAggNode {
8719                    agg_calls: agg_calls__.unwrap_or_default(),
8720                    agg_call_states: agg_call_states__.unwrap_or_default(),
8721                    intermediate_state_table: intermediate_state_table__,
8722                    is_append_only: is_append_only__.unwrap_or_default(),
8723                    distinct_dedup_tables: distinct_dedup_tables__.unwrap_or_default(),
8724                    row_count_index: row_count_index__.unwrap_or_default(),
8725                    version: version__.unwrap_or_default(),
8726                    must_output_per_barrier: must_output_per_barrier__.unwrap_or_default(),
8727                })
8728            }
8729        }
8730        deserializer.deserialize_struct("stream_plan.SimpleAggNode", FIELDS, GeneratedVisitor)
8731    }
8732}
8733impl serde::Serialize for SinkAddColumns {
8734    #[allow(deprecated)]
8735    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8736    where
8737        S: serde::Serializer,
8738    {
8739        use serde::ser::SerializeStruct;
8740        let mut len = 0;
8741        if !self.fields.is_empty() {
8742            len += 1;
8743        }
8744        let mut struct_ser = serializer.serialize_struct("stream_plan.SinkAddColumns", len)?;
8745        if !self.fields.is_empty() {
8746            struct_ser.serialize_field("fields", &self.fields)?;
8747        }
8748        struct_ser.end()
8749    }
8750}
8751impl<'de> serde::Deserialize<'de> for SinkAddColumns {
8752    #[allow(deprecated)]
8753    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8754    where
8755        D: serde::Deserializer<'de>,
8756    {
8757        const FIELDS: &[&str] = &[
8758            "fields",
8759        ];
8760
8761        #[allow(clippy::enum_variant_names)]
8762        enum GeneratedField {
8763            Fields,
8764        }
8765        impl<'de> serde::Deserialize<'de> for GeneratedField {
8766            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8767            where
8768                D: serde::Deserializer<'de>,
8769            {
8770                struct GeneratedVisitor;
8771
8772                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8773                    type Value = GeneratedField;
8774
8775                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8776                        write!(formatter, "expected one of: {:?}", &FIELDS)
8777                    }
8778
8779                    #[allow(unused_variables)]
8780                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8781                    where
8782                        E: serde::de::Error,
8783                    {
8784                        match value {
8785                            "fields" => Ok(GeneratedField::Fields),
8786                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
8787                        }
8788                    }
8789                }
8790                deserializer.deserialize_identifier(GeneratedVisitor)
8791            }
8792        }
8793        struct GeneratedVisitor;
8794        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8795            type Value = SinkAddColumns;
8796
8797            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8798                formatter.write_str("struct stream_plan.SinkAddColumns")
8799            }
8800
8801            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkAddColumns, V::Error>
8802                where
8803                    V: serde::de::MapAccess<'de>,
8804            {
8805                let mut fields__ = None;
8806                while let Some(k) = map_.next_key()? {
8807                    match k {
8808                        GeneratedField::Fields => {
8809                            if fields__.is_some() {
8810                                return Err(serde::de::Error::duplicate_field("fields"));
8811                            }
8812                            fields__ = Some(map_.next_value()?);
8813                        }
8814                    }
8815                }
8816                Ok(SinkAddColumns {
8817                    fields: fields__.unwrap_or_default(),
8818                })
8819            }
8820        }
8821        deserializer.deserialize_struct("stream_plan.SinkAddColumns", FIELDS, GeneratedVisitor)
8822    }
8823}
8824impl serde::Serialize for SinkDesc {
8825    #[allow(deprecated)]
8826    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
8827    where
8828        S: serde::Serializer,
8829    {
8830        use serde::ser::SerializeStruct;
8831        let mut len = 0;
8832        if self.id != 0 {
8833            len += 1;
8834        }
8835        if !self.name.is_empty() {
8836            len += 1;
8837        }
8838        if !self.definition.is_empty() {
8839            len += 1;
8840        }
8841        if !self.plan_pk.is_empty() {
8842            len += 1;
8843        }
8844        if !self.downstream_pk.is_empty() {
8845            len += 1;
8846        }
8847        if !self.distribution_key.is_empty() {
8848            len += 1;
8849        }
8850        if !self.properties.is_empty() {
8851            len += 1;
8852        }
8853        if self.sink_type != 0 {
8854            len += 1;
8855        }
8856        if !self.column_catalogs.is_empty() {
8857            len += 1;
8858        }
8859        if !self.db_name.is_empty() {
8860            len += 1;
8861        }
8862        if !self.sink_from_name.is_empty() {
8863            len += 1;
8864        }
8865        if self.format_desc.is_some() {
8866            len += 1;
8867        }
8868        if self.target_table.is_some() {
8869            len += 1;
8870        }
8871        if self.extra_partition_col_idx.is_some() {
8872            len += 1;
8873        }
8874        if !self.secret_refs.is_empty() {
8875            len += 1;
8876        }
8877        let mut struct_ser = serializer.serialize_struct("stream_plan.SinkDesc", len)?;
8878        if self.id != 0 {
8879            struct_ser.serialize_field("id", &self.id)?;
8880        }
8881        if !self.name.is_empty() {
8882            struct_ser.serialize_field("name", &self.name)?;
8883        }
8884        if !self.definition.is_empty() {
8885            struct_ser.serialize_field("definition", &self.definition)?;
8886        }
8887        if !self.plan_pk.is_empty() {
8888            struct_ser.serialize_field("planPk", &self.plan_pk)?;
8889        }
8890        if !self.downstream_pk.is_empty() {
8891            struct_ser.serialize_field("downstreamPk", &self.downstream_pk)?;
8892        }
8893        if !self.distribution_key.is_empty() {
8894            struct_ser.serialize_field("distributionKey", &self.distribution_key)?;
8895        }
8896        if !self.properties.is_empty() {
8897            struct_ser.serialize_field("properties", &self.properties)?;
8898        }
8899        if self.sink_type != 0 {
8900            let v = super::catalog::SinkType::try_from(self.sink_type)
8901                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.sink_type)))?;
8902            struct_ser.serialize_field("sinkType", &v)?;
8903        }
8904        if !self.column_catalogs.is_empty() {
8905            struct_ser.serialize_field("columnCatalogs", &self.column_catalogs)?;
8906        }
8907        if !self.db_name.is_empty() {
8908            struct_ser.serialize_field("dbName", &self.db_name)?;
8909        }
8910        if !self.sink_from_name.is_empty() {
8911            struct_ser.serialize_field("sinkFromName", &self.sink_from_name)?;
8912        }
8913        if let Some(v) = self.format_desc.as_ref() {
8914            struct_ser.serialize_field("formatDesc", v)?;
8915        }
8916        if let Some(v) = self.target_table.as_ref() {
8917            struct_ser.serialize_field("targetTable", v)?;
8918        }
8919        if let Some(v) = self.extra_partition_col_idx.as_ref() {
8920            #[allow(clippy::needless_borrow)]
8921            #[allow(clippy::needless_borrows_for_generic_args)]
8922            struct_ser.serialize_field("extraPartitionColIdx", ToString::to_string(&v).as_str())?;
8923        }
8924        if !self.secret_refs.is_empty() {
8925            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
8926        }
8927        struct_ser.end()
8928    }
8929}
8930impl<'de> serde::Deserialize<'de> for SinkDesc {
8931    #[allow(deprecated)]
8932    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
8933    where
8934        D: serde::Deserializer<'de>,
8935    {
8936        const FIELDS: &[&str] = &[
8937            "id",
8938            "name",
8939            "definition",
8940            "plan_pk",
8941            "planPk",
8942            "downstream_pk",
8943            "downstreamPk",
8944            "distribution_key",
8945            "distributionKey",
8946            "properties",
8947            "sink_type",
8948            "sinkType",
8949            "column_catalogs",
8950            "columnCatalogs",
8951            "db_name",
8952            "dbName",
8953            "sink_from_name",
8954            "sinkFromName",
8955            "format_desc",
8956            "formatDesc",
8957            "target_table",
8958            "targetTable",
8959            "extra_partition_col_idx",
8960            "extraPartitionColIdx",
8961            "secret_refs",
8962            "secretRefs",
8963        ];
8964
8965        #[allow(clippy::enum_variant_names)]
8966        enum GeneratedField {
8967            Id,
8968            Name,
8969            Definition,
8970            PlanPk,
8971            DownstreamPk,
8972            DistributionKey,
8973            Properties,
8974            SinkType,
8975            ColumnCatalogs,
8976            DbName,
8977            SinkFromName,
8978            FormatDesc,
8979            TargetTable,
8980            ExtraPartitionColIdx,
8981            SecretRefs,
8982        }
8983        impl<'de> serde::Deserialize<'de> for GeneratedField {
8984            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
8985            where
8986                D: serde::Deserializer<'de>,
8987            {
8988                struct GeneratedVisitor;
8989
8990                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
8991                    type Value = GeneratedField;
8992
8993                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
8994                        write!(formatter, "expected one of: {:?}", &FIELDS)
8995                    }
8996
8997                    #[allow(unused_variables)]
8998                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
8999                    where
9000                        E: serde::de::Error,
9001                    {
9002                        match value {
9003                            "id" => Ok(GeneratedField::Id),
9004                            "name" => Ok(GeneratedField::Name),
9005                            "definition" => Ok(GeneratedField::Definition),
9006                            "planPk" | "plan_pk" => Ok(GeneratedField::PlanPk),
9007                            "downstreamPk" | "downstream_pk" => Ok(GeneratedField::DownstreamPk),
9008                            "distributionKey" | "distribution_key" => Ok(GeneratedField::DistributionKey),
9009                            "properties" => Ok(GeneratedField::Properties),
9010                            "sinkType" | "sink_type" => Ok(GeneratedField::SinkType),
9011                            "columnCatalogs" | "column_catalogs" => Ok(GeneratedField::ColumnCatalogs),
9012                            "dbName" | "db_name" => Ok(GeneratedField::DbName),
9013                            "sinkFromName" | "sink_from_name" => Ok(GeneratedField::SinkFromName),
9014                            "formatDesc" | "format_desc" => Ok(GeneratedField::FormatDesc),
9015                            "targetTable" | "target_table" => Ok(GeneratedField::TargetTable),
9016                            "extraPartitionColIdx" | "extra_partition_col_idx" => Ok(GeneratedField::ExtraPartitionColIdx),
9017                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9018                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9019                        }
9020                    }
9021                }
9022                deserializer.deserialize_identifier(GeneratedVisitor)
9023            }
9024        }
9025        struct GeneratedVisitor;
9026        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9027            type Value = SinkDesc;
9028
9029            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9030                formatter.write_str("struct stream_plan.SinkDesc")
9031            }
9032
9033            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkDesc, V::Error>
9034                where
9035                    V: serde::de::MapAccess<'de>,
9036            {
9037                let mut id__ = None;
9038                let mut name__ = None;
9039                let mut definition__ = None;
9040                let mut plan_pk__ = None;
9041                let mut downstream_pk__ = None;
9042                let mut distribution_key__ = None;
9043                let mut properties__ = None;
9044                let mut sink_type__ = None;
9045                let mut column_catalogs__ = None;
9046                let mut db_name__ = None;
9047                let mut sink_from_name__ = None;
9048                let mut format_desc__ = None;
9049                let mut target_table__ = None;
9050                let mut extra_partition_col_idx__ = None;
9051                let mut secret_refs__ = None;
9052                while let Some(k) = map_.next_key()? {
9053                    match k {
9054                        GeneratedField::Id => {
9055                            if id__.is_some() {
9056                                return Err(serde::de::Error::duplicate_field("id"));
9057                            }
9058                            id__ = 
9059                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9060                            ;
9061                        }
9062                        GeneratedField::Name => {
9063                            if name__.is_some() {
9064                                return Err(serde::de::Error::duplicate_field("name"));
9065                            }
9066                            name__ = Some(map_.next_value()?);
9067                        }
9068                        GeneratedField::Definition => {
9069                            if definition__.is_some() {
9070                                return Err(serde::de::Error::duplicate_field("definition"));
9071                            }
9072                            definition__ = Some(map_.next_value()?);
9073                        }
9074                        GeneratedField::PlanPk => {
9075                            if plan_pk__.is_some() {
9076                                return Err(serde::de::Error::duplicate_field("planPk"));
9077                            }
9078                            plan_pk__ = Some(map_.next_value()?);
9079                        }
9080                        GeneratedField::DownstreamPk => {
9081                            if downstream_pk__.is_some() {
9082                                return Err(serde::de::Error::duplicate_field("downstreamPk"));
9083                            }
9084                            downstream_pk__ = 
9085                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9086                                    .into_iter().map(|x| x.0).collect())
9087                            ;
9088                        }
9089                        GeneratedField::DistributionKey => {
9090                            if distribution_key__.is_some() {
9091                                return Err(serde::de::Error::duplicate_field("distributionKey"));
9092                            }
9093                            distribution_key__ = 
9094                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
9095                                    .into_iter().map(|x| x.0).collect())
9096                            ;
9097                        }
9098                        GeneratedField::Properties => {
9099                            if properties__.is_some() {
9100                                return Err(serde::de::Error::duplicate_field("properties"));
9101                            }
9102                            properties__ = Some(
9103                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
9104                            );
9105                        }
9106                        GeneratedField::SinkType => {
9107                            if sink_type__.is_some() {
9108                                return Err(serde::de::Error::duplicate_field("sinkType"));
9109                            }
9110                            sink_type__ = Some(map_.next_value::<super::catalog::SinkType>()? as i32);
9111                        }
9112                        GeneratedField::ColumnCatalogs => {
9113                            if column_catalogs__.is_some() {
9114                                return Err(serde::de::Error::duplicate_field("columnCatalogs"));
9115                            }
9116                            column_catalogs__ = Some(map_.next_value()?);
9117                        }
9118                        GeneratedField::DbName => {
9119                            if db_name__.is_some() {
9120                                return Err(serde::de::Error::duplicate_field("dbName"));
9121                            }
9122                            db_name__ = Some(map_.next_value()?);
9123                        }
9124                        GeneratedField::SinkFromName => {
9125                            if sink_from_name__.is_some() {
9126                                return Err(serde::de::Error::duplicate_field("sinkFromName"));
9127                            }
9128                            sink_from_name__ = Some(map_.next_value()?);
9129                        }
9130                        GeneratedField::FormatDesc => {
9131                            if format_desc__.is_some() {
9132                                return Err(serde::de::Error::duplicate_field("formatDesc"));
9133                            }
9134                            format_desc__ = map_.next_value()?;
9135                        }
9136                        GeneratedField::TargetTable => {
9137                            if target_table__.is_some() {
9138                                return Err(serde::de::Error::duplicate_field("targetTable"));
9139                            }
9140                            target_table__ = 
9141                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9142                            ;
9143                        }
9144                        GeneratedField::ExtraPartitionColIdx => {
9145                            if extra_partition_col_idx__.is_some() {
9146                                return Err(serde::de::Error::duplicate_field("extraPartitionColIdx"));
9147                            }
9148                            extra_partition_col_idx__ = 
9149                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9150                            ;
9151                        }
9152                        GeneratedField::SecretRefs => {
9153                            if secret_refs__.is_some() {
9154                                return Err(serde::de::Error::duplicate_field("secretRefs"));
9155                            }
9156                            secret_refs__ = Some(
9157                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
9158                            );
9159                        }
9160                    }
9161                }
9162                Ok(SinkDesc {
9163                    id: id__.unwrap_or_default(),
9164                    name: name__.unwrap_or_default(),
9165                    definition: definition__.unwrap_or_default(),
9166                    plan_pk: plan_pk__.unwrap_or_default(),
9167                    downstream_pk: downstream_pk__.unwrap_or_default(),
9168                    distribution_key: distribution_key__.unwrap_or_default(),
9169                    properties: properties__.unwrap_or_default(),
9170                    sink_type: sink_type__.unwrap_or_default(),
9171                    column_catalogs: column_catalogs__.unwrap_or_default(),
9172                    db_name: db_name__.unwrap_or_default(),
9173                    sink_from_name: sink_from_name__.unwrap_or_default(),
9174                    format_desc: format_desc__,
9175                    target_table: target_table__,
9176                    extra_partition_col_idx: extra_partition_col_idx__,
9177                    secret_refs: secret_refs__.unwrap_or_default(),
9178                })
9179            }
9180        }
9181        deserializer.deserialize_struct("stream_plan.SinkDesc", FIELDS, GeneratedVisitor)
9182    }
9183}
9184impl serde::Serialize for SinkLogStoreType {
9185    #[allow(deprecated)]
9186    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9187    where
9188        S: serde::Serializer,
9189    {
9190        let variant = match self {
9191            Self::Unspecified => "SINK_LOG_STORE_TYPE_UNSPECIFIED",
9192            Self::KvLogStore => "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
9193            Self::InMemoryLogStore => "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
9194        };
9195        serializer.serialize_str(variant)
9196    }
9197}
9198impl<'de> serde::Deserialize<'de> for SinkLogStoreType {
9199    #[allow(deprecated)]
9200    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9201    where
9202        D: serde::Deserializer<'de>,
9203    {
9204        const FIELDS: &[&str] = &[
9205            "SINK_LOG_STORE_TYPE_UNSPECIFIED",
9206            "SINK_LOG_STORE_TYPE_KV_LOG_STORE",
9207            "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE",
9208        ];
9209
9210        struct GeneratedVisitor;
9211
9212        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9213            type Value = SinkLogStoreType;
9214
9215            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9216                write!(formatter, "expected one of: {:?}", &FIELDS)
9217            }
9218
9219            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
9220            where
9221                E: serde::de::Error,
9222            {
9223                i32::try_from(v)
9224                    .ok()
9225                    .and_then(|x| x.try_into().ok())
9226                    .ok_or_else(|| {
9227                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
9228                    })
9229            }
9230
9231            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
9232            where
9233                E: serde::de::Error,
9234            {
9235                i32::try_from(v)
9236                    .ok()
9237                    .and_then(|x| x.try_into().ok())
9238                    .ok_or_else(|| {
9239                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
9240                    })
9241            }
9242
9243            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
9244            where
9245                E: serde::de::Error,
9246            {
9247                match value {
9248                    "SINK_LOG_STORE_TYPE_UNSPECIFIED" => Ok(SinkLogStoreType::Unspecified),
9249                    "SINK_LOG_STORE_TYPE_KV_LOG_STORE" => Ok(SinkLogStoreType::KvLogStore),
9250                    "SINK_LOG_STORE_TYPE_IN_MEMORY_LOG_STORE" => Ok(SinkLogStoreType::InMemoryLogStore),
9251                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
9252                }
9253            }
9254        }
9255        deserializer.deserialize_any(GeneratedVisitor)
9256    }
9257}
9258impl serde::Serialize for SinkNode {
9259    #[allow(deprecated)]
9260    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9261    where
9262        S: serde::Serializer,
9263    {
9264        use serde::ser::SerializeStruct;
9265        let mut len = 0;
9266        if self.sink_desc.is_some() {
9267            len += 1;
9268        }
9269        if self.table.is_some() {
9270            len += 1;
9271        }
9272        if self.log_store_type != 0 {
9273            len += 1;
9274        }
9275        if self.rate_limit.is_some() {
9276            len += 1;
9277        }
9278        let mut struct_ser = serializer.serialize_struct("stream_plan.SinkNode", len)?;
9279        if let Some(v) = self.sink_desc.as_ref() {
9280            struct_ser.serialize_field("sinkDesc", v)?;
9281        }
9282        if let Some(v) = self.table.as_ref() {
9283            struct_ser.serialize_field("table", v)?;
9284        }
9285        if self.log_store_type != 0 {
9286            let v = SinkLogStoreType::try_from(self.log_store_type)
9287                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.log_store_type)))?;
9288            struct_ser.serialize_field("logStoreType", &v)?;
9289        }
9290        if let Some(v) = self.rate_limit.as_ref() {
9291            struct_ser.serialize_field("rateLimit", v)?;
9292        }
9293        struct_ser.end()
9294    }
9295}
9296impl<'de> serde::Deserialize<'de> for SinkNode {
9297    #[allow(deprecated)]
9298    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9299    where
9300        D: serde::Deserializer<'de>,
9301    {
9302        const FIELDS: &[&str] = &[
9303            "sink_desc",
9304            "sinkDesc",
9305            "table",
9306            "log_store_type",
9307            "logStoreType",
9308            "rate_limit",
9309            "rateLimit",
9310        ];
9311
9312        #[allow(clippy::enum_variant_names)]
9313        enum GeneratedField {
9314            SinkDesc,
9315            Table,
9316            LogStoreType,
9317            RateLimit,
9318        }
9319        impl<'de> serde::Deserialize<'de> for GeneratedField {
9320            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9321            where
9322                D: serde::Deserializer<'de>,
9323            {
9324                struct GeneratedVisitor;
9325
9326                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9327                    type Value = GeneratedField;
9328
9329                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9330                        write!(formatter, "expected one of: {:?}", &FIELDS)
9331                    }
9332
9333                    #[allow(unused_variables)]
9334                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9335                    where
9336                        E: serde::de::Error,
9337                    {
9338                        match value {
9339                            "sinkDesc" | "sink_desc" => Ok(GeneratedField::SinkDesc),
9340                            "table" => Ok(GeneratedField::Table),
9341                            "logStoreType" | "log_store_type" => Ok(GeneratedField::LogStoreType),
9342                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9343                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9344                        }
9345                    }
9346                }
9347                deserializer.deserialize_identifier(GeneratedVisitor)
9348            }
9349        }
9350        struct GeneratedVisitor;
9351        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9352            type Value = SinkNode;
9353
9354            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9355                formatter.write_str("struct stream_plan.SinkNode")
9356            }
9357
9358            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SinkNode, V::Error>
9359                where
9360                    V: serde::de::MapAccess<'de>,
9361            {
9362                let mut sink_desc__ = None;
9363                let mut table__ = None;
9364                let mut log_store_type__ = None;
9365                let mut rate_limit__ = None;
9366                while let Some(k) = map_.next_key()? {
9367                    match k {
9368                        GeneratedField::SinkDesc => {
9369                            if sink_desc__.is_some() {
9370                                return Err(serde::de::Error::duplicate_field("sinkDesc"));
9371                            }
9372                            sink_desc__ = map_.next_value()?;
9373                        }
9374                        GeneratedField::Table => {
9375                            if table__.is_some() {
9376                                return Err(serde::de::Error::duplicate_field("table"));
9377                            }
9378                            table__ = map_.next_value()?;
9379                        }
9380                        GeneratedField::LogStoreType => {
9381                            if log_store_type__.is_some() {
9382                                return Err(serde::de::Error::duplicate_field("logStoreType"));
9383                            }
9384                            log_store_type__ = Some(map_.next_value::<SinkLogStoreType>()? as i32);
9385                        }
9386                        GeneratedField::RateLimit => {
9387                            if rate_limit__.is_some() {
9388                                return Err(serde::de::Error::duplicate_field("rateLimit"));
9389                            }
9390                            rate_limit__ = 
9391                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9392                            ;
9393                        }
9394                    }
9395                }
9396                Ok(SinkNode {
9397                    sink_desc: sink_desc__,
9398                    table: table__,
9399                    log_store_type: log_store_type__.unwrap_or_default(),
9400                    rate_limit: rate_limit__,
9401                })
9402            }
9403        }
9404        deserializer.deserialize_struct("stream_plan.SinkNode", FIELDS, GeneratedVisitor)
9405    }
9406}
9407impl serde::Serialize for SortNode {
9408    #[allow(deprecated)]
9409    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9410    where
9411        S: serde::Serializer,
9412    {
9413        use serde::ser::SerializeStruct;
9414        let mut len = 0;
9415        if self.state_table.is_some() {
9416            len += 1;
9417        }
9418        if self.sort_column_index != 0 {
9419            len += 1;
9420        }
9421        let mut struct_ser = serializer.serialize_struct("stream_plan.SortNode", len)?;
9422        if let Some(v) = self.state_table.as_ref() {
9423            struct_ser.serialize_field("stateTable", v)?;
9424        }
9425        if self.sort_column_index != 0 {
9426            struct_ser.serialize_field("sortColumnIndex", &self.sort_column_index)?;
9427        }
9428        struct_ser.end()
9429    }
9430}
9431impl<'de> serde::Deserialize<'de> for SortNode {
9432    #[allow(deprecated)]
9433    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9434    where
9435        D: serde::Deserializer<'de>,
9436    {
9437        const FIELDS: &[&str] = &[
9438            "state_table",
9439            "stateTable",
9440            "sort_column_index",
9441            "sortColumnIndex",
9442        ];
9443
9444        #[allow(clippy::enum_variant_names)]
9445        enum GeneratedField {
9446            StateTable,
9447            SortColumnIndex,
9448        }
9449        impl<'de> serde::Deserialize<'de> for GeneratedField {
9450            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9451            where
9452                D: serde::Deserializer<'de>,
9453            {
9454                struct GeneratedVisitor;
9455
9456                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9457                    type Value = GeneratedField;
9458
9459                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9460                        write!(formatter, "expected one of: {:?}", &FIELDS)
9461                    }
9462
9463                    #[allow(unused_variables)]
9464                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9465                    where
9466                        E: serde::de::Error,
9467                    {
9468                        match value {
9469                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9470                            "sortColumnIndex" | "sort_column_index" => Ok(GeneratedField::SortColumnIndex),
9471                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9472                        }
9473                    }
9474                }
9475                deserializer.deserialize_identifier(GeneratedVisitor)
9476            }
9477        }
9478        struct GeneratedVisitor;
9479        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9480            type Value = SortNode;
9481
9482            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9483                formatter.write_str("struct stream_plan.SortNode")
9484            }
9485
9486            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SortNode, V::Error>
9487                where
9488                    V: serde::de::MapAccess<'de>,
9489            {
9490                let mut state_table__ = None;
9491                let mut sort_column_index__ = None;
9492                while let Some(k) = map_.next_key()? {
9493                    match k {
9494                        GeneratedField::StateTable => {
9495                            if state_table__.is_some() {
9496                                return Err(serde::de::Error::duplicate_field("stateTable"));
9497                            }
9498                            state_table__ = map_.next_value()?;
9499                        }
9500                        GeneratedField::SortColumnIndex => {
9501                            if sort_column_index__.is_some() {
9502                                return Err(serde::de::Error::duplicate_field("sortColumnIndex"));
9503                            }
9504                            sort_column_index__ = 
9505                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9506                            ;
9507                        }
9508                    }
9509                }
9510                Ok(SortNode {
9511                    state_table: state_table__,
9512                    sort_column_index: sort_column_index__.unwrap_or_default(),
9513                })
9514            }
9515        }
9516        deserializer.deserialize_struct("stream_plan.SortNode", FIELDS, GeneratedVisitor)
9517    }
9518}
9519impl serde::Serialize for SourceBackfillNode {
9520    #[allow(deprecated)]
9521    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9522    where
9523        S: serde::Serializer,
9524    {
9525        use serde::ser::SerializeStruct;
9526        let mut len = 0;
9527        if self.upstream_source_id != 0 {
9528            len += 1;
9529        }
9530        if self.row_id_index.is_some() {
9531            len += 1;
9532        }
9533        if !self.columns.is_empty() {
9534            len += 1;
9535        }
9536        if self.info.is_some() {
9537            len += 1;
9538        }
9539        if !self.source_name.is_empty() {
9540            len += 1;
9541        }
9542        if !self.with_properties.is_empty() {
9543            len += 1;
9544        }
9545        if self.rate_limit.is_some() {
9546            len += 1;
9547        }
9548        if self.state_table.is_some() {
9549            len += 1;
9550        }
9551        if !self.secret_refs.is_empty() {
9552            len += 1;
9553        }
9554        let mut struct_ser = serializer.serialize_struct("stream_plan.SourceBackfillNode", len)?;
9555        if self.upstream_source_id != 0 {
9556            struct_ser.serialize_field("upstreamSourceId", &self.upstream_source_id)?;
9557        }
9558        if let Some(v) = self.row_id_index.as_ref() {
9559            struct_ser.serialize_field("rowIdIndex", v)?;
9560        }
9561        if !self.columns.is_empty() {
9562            struct_ser.serialize_field("columns", &self.columns)?;
9563        }
9564        if let Some(v) = self.info.as_ref() {
9565            struct_ser.serialize_field("info", v)?;
9566        }
9567        if !self.source_name.is_empty() {
9568            struct_ser.serialize_field("sourceName", &self.source_name)?;
9569        }
9570        if !self.with_properties.is_empty() {
9571            struct_ser.serialize_field("withProperties", &self.with_properties)?;
9572        }
9573        if let Some(v) = self.rate_limit.as_ref() {
9574            struct_ser.serialize_field("rateLimit", v)?;
9575        }
9576        if let Some(v) = self.state_table.as_ref() {
9577            struct_ser.serialize_field("stateTable", v)?;
9578        }
9579        if !self.secret_refs.is_empty() {
9580            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
9581        }
9582        struct_ser.end()
9583    }
9584}
9585impl<'de> serde::Deserialize<'de> for SourceBackfillNode {
9586    #[allow(deprecated)]
9587    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9588    where
9589        D: serde::Deserializer<'de>,
9590    {
9591        const FIELDS: &[&str] = &[
9592            "upstream_source_id",
9593            "upstreamSourceId",
9594            "row_id_index",
9595            "rowIdIndex",
9596            "columns",
9597            "info",
9598            "source_name",
9599            "sourceName",
9600            "with_properties",
9601            "withProperties",
9602            "rate_limit",
9603            "rateLimit",
9604            "state_table",
9605            "stateTable",
9606            "secret_refs",
9607            "secretRefs",
9608        ];
9609
9610        #[allow(clippy::enum_variant_names)]
9611        enum GeneratedField {
9612            UpstreamSourceId,
9613            RowIdIndex,
9614            Columns,
9615            Info,
9616            SourceName,
9617            WithProperties,
9618            RateLimit,
9619            StateTable,
9620            SecretRefs,
9621        }
9622        impl<'de> serde::Deserialize<'de> for GeneratedField {
9623            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9624            where
9625                D: serde::Deserializer<'de>,
9626            {
9627                struct GeneratedVisitor;
9628
9629                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9630                    type Value = GeneratedField;
9631
9632                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9633                        write!(formatter, "expected one of: {:?}", &FIELDS)
9634                    }
9635
9636                    #[allow(unused_variables)]
9637                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9638                    where
9639                        E: serde::de::Error,
9640                    {
9641                        match value {
9642                            "upstreamSourceId" | "upstream_source_id" => Ok(GeneratedField::UpstreamSourceId),
9643                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
9644                            "columns" => Ok(GeneratedField::Columns),
9645                            "info" => Ok(GeneratedField::Info),
9646                            "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
9647                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
9648                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
9649                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
9650                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
9651                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9652                        }
9653                    }
9654                }
9655                deserializer.deserialize_identifier(GeneratedVisitor)
9656            }
9657        }
9658        struct GeneratedVisitor;
9659        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9660            type Value = SourceBackfillNode;
9661
9662            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9663                formatter.write_str("struct stream_plan.SourceBackfillNode")
9664            }
9665
9666            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceBackfillNode, V::Error>
9667                where
9668                    V: serde::de::MapAccess<'de>,
9669            {
9670                let mut upstream_source_id__ = None;
9671                let mut row_id_index__ = None;
9672                let mut columns__ = None;
9673                let mut info__ = None;
9674                let mut source_name__ = None;
9675                let mut with_properties__ = None;
9676                let mut rate_limit__ = None;
9677                let mut state_table__ = None;
9678                let mut secret_refs__ = None;
9679                while let Some(k) = map_.next_key()? {
9680                    match k {
9681                        GeneratedField::UpstreamSourceId => {
9682                            if upstream_source_id__.is_some() {
9683                                return Err(serde::de::Error::duplicate_field("upstreamSourceId"));
9684                            }
9685                            upstream_source_id__ = 
9686                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
9687                            ;
9688                        }
9689                        GeneratedField::RowIdIndex => {
9690                            if row_id_index__.is_some() {
9691                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
9692                            }
9693                            row_id_index__ = 
9694                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9695                            ;
9696                        }
9697                        GeneratedField::Columns => {
9698                            if columns__.is_some() {
9699                                return Err(serde::de::Error::duplicate_field("columns"));
9700                            }
9701                            columns__ = Some(map_.next_value()?);
9702                        }
9703                        GeneratedField::Info => {
9704                            if info__.is_some() {
9705                                return Err(serde::de::Error::duplicate_field("info"));
9706                            }
9707                            info__ = map_.next_value()?;
9708                        }
9709                        GeneratedField::SourceName => {
9710                            if source_name__.is_some() {
9711                                return Err(serde::de::Error::duplicate_field("sourceName"));
9712                            }
9713                            source_name__ = Some(map_.next_value()?);
9714                        }
9715                        GeneratedField::WithProperties => {
9716                            if with_properties__.is_some() {
9717                                return Err(serde::de::Error::duplicate_field("withProperties"));
9718                            }
9719                            with_properties__ = Some(
9720                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
9721                            );
9722                        }
9723                        GeneratedField::RateLimit => {
9724                            if rate_limit__.is_some() {
9725                                return Err(serde::de::Error::duplicate_field("rateLimit"));
9726                            }
9727                            rate_limit__ = 
9728                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
9729                            ;
9730                        }
9731                        GeneratedField::StateTable => {
9732                            if state_table__.is_some() {
9733                                return Err(serde::de::Error::duplicate_field("stateTable"));
9734                            }
9735                            state_table__ = map_.next_value()?;
9736                        }
9737                        GeneratedField::SecretRefs => {
9738                            if secret_refs__.is_some() {
9739                                return Err(serde::de::Error::duplicate_field("secretRefs"));
9740                            }
9741                            secret_refs__ = Some(
9742                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
9743                            );
9744                        }
9745                    }
9746                }
9747                Ok(SourceBackfillNode {
9748                    upstream_source_id: upstream_source_id__.unwrap_or_default(),
9749                    row_id_index: row_id_index__,
9750                    columns: columns__.unwrap_or_default(),
9751                    info: info__,
9752                    source_name: source_name__.unwrap_or_default(),
9753                    with_properties: with_properties__.unwrap_or_default(),
9754                    rate_limit: rate_limit__,
9755                    state_table: state_table__,
9756                    secret_refs: secret_refs__.unwrap_or_default(),
9757                })
9758            }
9759        }
9760        deserializer.deserialize_struct("stream_plan.SourceBackfillNode", FIELDS, GeneratedVisitor)
9761    }
9762}
9763impl serde::Serialize for SourceChangeSplitMutation {
9764    #[allow(deprecated)]
9765    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9766    where
9767        S: serde::Serializer,
9768    {
9769        use serde::ser::SerializeStruct;
9770        let mut len = 0;
9771        if !self.actor_splits.is_empty() {
9772            len += 1;
9773        }
9774        let mut struct_ser = serializer.serialize_struct("stream_plan.SourceChangeSplitMutation", len)?;
9775        if !self.actor_splits.is_empty() {
9776            struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
9777        }
9778        struct_ser.end()
9779    }
9780}
9781impl<'de> serde::Deserialize<'de> for SourceChangeSplitMutation {
9782    #[allow(deprecated)]
9783    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9784    where
9785        D: serde::Deserializer<'de>,
9786    {
9787        const FIELDS: &[&str] = &[
9788            "actor_splits",
9789            "actorSplits",
9790        ];
9791
9792        #[allow(clippy::enum_variant_names)]
9793        enum GeneratedField {
9794            ActorSplits,
9795        }
9796        impl<'de> serde::Deserialize<'de> for GeneratedField {
9797            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9798            where
9799                D: serde::Deserializer<'de>,
9800            {
9801                struct GeneratedVisitor;
9802
9803                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9804                    type Value = GeneratedField;
9805
9806                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9807                        write!(formatter, "expected one of: {:?}", &FIELDS)
9808                    }
9809
9810                    #[allow(unused_variables)]
9811                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9812                    where
9813                        E: serde::de::Error,
9814                    {
9815                        match value {
9816                            "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
9817                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9818                        }
9819                    }
9820                }
9821                deserializer.deserialize_identifier(GeneratedVisitor)
9822            }
9823        }
9824        struct GeneratedVisitor;
9825        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9826            type Value = SourceChangeSplitMutation;
9827
9828            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9829                formatter.write_str("struct stream_plan.SourceChangeSplitMutation")
9830            }
9831
9832            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceChangeSplitMutation, V::Error>
9833                where
9834                    V: serde::de::MapAccess<'de>,
9835            {
9836                let mut actor_splits__ = None;
9837                while let Some(k) = map_.next_key()? {
9838                    match k {
9839                        GeneratedField::ActorSplits => {
9840                            if actor_splits__.is_some() {
9841                                return Err(serde::de::Error::duplicate_field("actorSplits"));
9842                            }
9843                            actor_splits__ = Some(
9844                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
9845                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
9846                            );
9847                        }
9848                    }
9849                }
9850                Ok(SourceChangeSplitMutation {
9851                    actor_splits: actor_splits__.unwrap_or_default(),
9852                })
9853            }
9854        }
9855        deserializer.deserialize_struct("stream_plan.SourceChangeSplitMutation", FIELDS, GeneratedVisitor)
9856    }
9857}
9858impl serde::Serialize for SourceNode {
9859    #[allow(deprecated)]
9860    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9861    where
9862        S: serde::Serializer,
9863    {
9864        use serde::ser::SerializeStruct;
9865        let mut len = 0;
9866        if self.source_inner.is_some() {
9867            len += 1;
9868        }
9869        let mut struct_ser = serializer.serialize_struct("stream_plan.SourceNode", len)?;
9870        if let Some(v) = self.source_inner.as_ref() {
9871            struct_ser.serialize_field("sourceInner", v)?;
9872        }
9873        struct_ser.end()
9874    }
9875}
9876impl<'de> serde::Deserialize<'de> for SourceNode {
9877    #[allow(deprecated)]
9878    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9879    where
9880        D: serde::Deserializer<'de>,
9881    {
9882        const FIELDS: &[&str] = &[
9883            "source_inner",
9884            "sourceInner",
9885        ];
9886
9887        #[allow(clippy::enum_variant_names)]
9888        enum GeneratedField {
9889            SourceInner,
9890        }
9891        impl<'de> serde::Deserialize<'de> for GeneratedField {
9892            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9893            where
9894                D: serde::Deserializer<'de>,
9895            {
9896                struct GeneratedVisitor;
9897
9898                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9899                    type Value = GeneratedField;
9900
9901                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9902                        write!(formatter, "expected one of: {:?}", &FIELDS)
9903                    }
9904
9905                    #[allow(unused_variables)]
9906                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9907                    where
9908                        E: serde::de::Error,
9909                    {
9910                        match value {
9911                            "sourceInner" | "source_inner" => Ok(GeneratedField::SourceInner),
9912                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
9913                        }
9914                    }
9915                }
9916                deserializer.deserialize_identifier(GeneratedVisitor)
9917            }
9918        }
9919        struct GeneratedVisitor;
9920        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9921            type Value = SourceNode;
9922
9923            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9924                formatter.write_str("struct stream_plan.SourceNode")
9925            }
9926
9927            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SourceNode, V::Error>
9928                where
9929                    V: serde::de::MapAccess<'de>,
9930            {
9931                let mut source_inner__ = None;
9932                while let Some(k) = map_.next_key()? {
9933                    match k {
9934                        GeneratedField::SourceInner => {
9935                            if source_inner__.is_some() {
9936                                return Err(serde::de::Error::duplicate_field("sourceInner"));
9937                            }
9938                            source_inner__ = map_.next_value()?;
9939                        }
9940                    }
9941                }
9942                Ok(SourceNode {
9943                    source_inner: source_inner__,
9944                })
9945            }
9946        }
9947        deserializer.deserialize_struct("stream_plan.SourceNode", FIELDS, GeneratedVisitor)
9948    }
9949}
9950impl serde::Serialize for StartFragmentBackfillMutation {
9951    #[allow(deprecated)]
9952    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
9953    where
9954        S: serde::Serializer,
9955    {
9956        use serde::ser::SerializeStruct;
9957        let mut len = 0;
9958        if !self.fragment_ids.is_empty() {
9959            len += 1;
9960        }
9961        let mut struct_ser = serializer.serialize_struct("stream_plan.StartFragmentBackfillMutation", len)?;
9962        if !self.fragment_ids.is_empty() {
9963            struct_ser.serialize_field("fragmentIds", &self.fragment_ids)?;
9964        }
9965        struct_ser.end()
9966    }
9967}
9968impl<'de> serde::Deserialize<'de> for StartFragmentBackfillMutation {
9969    #[allow(deprecated)]
9970    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
9971    where
9972        D: serde::Deserializer<'de>,
9973    {
9974        const FIELDS: &[&str] = &[
9975            "fragment_ids",
9976            "fragmentIds",
9977        ];
9978
9979        #[allow(clippy::enum_variant_names)]
9980        enum GeneratedField {
9981            FragmentIds,
9982        }
9983        impl<'de> serde::Deserialize<'de> for GeneratedField {
9984            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
9985            where
9986                D: serde::Deserializer<'de>,
9987            {
9988                struct GeneratedVisitor;
9989
9990                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
9991                    type Value = GeneratedField;
9992
9993                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
9994                        write!(formatter, "expected one of: {:?}", &FIELDS)
9995                    }
9996
9997                    #[allow(unused_variables)]
9998                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
9999                    where
10000                        E: serde::de::Error,
10001                    {
10002                        match value {
10003                            "fragmentIds" | "fragment_ids" => Ok(GeneratedField::FragmentIds),
10004                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10005                        }
10006                    }
10007                }
10008                deserializer.deserialize_identifier(GeneratedVisitor)
10009            }
10010        }
10011        struct GeneratedVisitor;
10012        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10013            type Value = StartFragmentBackfillMutation;
10014
10015            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10016                formatter.write_str("struct stream_plan.StartFragmentBackfillMutation")
10017            }
10018
10019            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StartFragmentBackfillMutation, V::Error>
10020                where
10021                    V: serde::de::MapAccess<'de>,
10022            {
10023                let mut fragment_ids__ = None;
10024                while let Some(k) = map_.next_key()? {
10025                    match k {
10026                        GeneratedField::FragmentIds => {
10027                            if fragment_ids__.is_some() {
10028                                return Err(serde::de::Error::duplicate_field("fragmentIds"));
10029                            }
10030                            fragment_ids__ = 
10031                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10032                                    .into_iter().map(|x| x.0).collect())
10033                            ;
10034                        }
10035                    }
10036                }
10037                Ok(StartFragmentBackfillMutation {
10038                    fragment_ids: fragment_ids__.unwrap_or_default(),
10039                })
10040            }
10041        }
10042        deserializer.deserialize_struct("stream_plan.StartFragmentBackfillMutation", FIELDS, GeneratedVisitor)
10043    }
10044}
10045impl serde::Serialize for StopMutation {
10046    #[allow(deprecated)]
10047    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10048    where
10049        S: serde::Serializer,
10050    {
10051        use serde::ser::SerializeStruct;
10052        let mut len = 0;
10053        if !self.actors.is_empty() {
10054            len += 1;
10055        }
10056        if !self.dropped_sink_fragments.is_empty() {
10057            len += 1;
10058        }
10059        let mut struct_ser = serializer.serialize_struct("stream_plan.StopMutation", len)?;
10060        if !self.actors.is_empty() {
10061            struct_ser.serialize_field("actors", &self.actors)?;
10062        }
10063        if !self.dropped_sink_fragments.is_empty() {
10064            struct_ser.serialize_field("droppedSinkFragments", &self.dropped_sink_fragments)?;
10065        }
10066        struct_ser.end()
10067    }
10068}
10069impl<'de> serde::Deserialize<'de> for StopMutation {
10070    #[allow(deprecated)]
10071    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10072    where
10073        D: serde::Deserializer<'de>,
10074    {
10075        const FIELDS: &[&str] = &[
10076            "actors",
10077            "dropped_sink_fragments",
10078            "droppedSinkFragments",
10079        ];
10080
10081        #[allow(clippy::enum_variant_names)]
10082        enum GeneratedField {
10083            Actors,
10084            DroppedSinkFragments,
10085        }
10086        impl<'de> serde::Deserialize<'de> for GeneratedField {
10087            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10088            where
10089                D: serde::Deserializer<'de>,
10090            {
10091                struct GeneratedVisitor;
10092
10093                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10094                    type Value = GeneratedField;
10095
10096                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10097                        write!(formatter, "expected one of: {:?}", &FIELDS)
10098                    }
10099
10100                    #[allow(unused_variables)]
10101                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10102                    where
10103                        E: serde::de::Error,
10104                    {
10105                        match value {
10106                            "actors" => Ok(GeneratedField::Actors),
10107                            "droppedSinkFragments" | "dropped_sink_fragments" => Ok(GeneratedField::DroppedSinkFragments),
10108                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10109                        }
10110                    }
10111                }
10112                deserializer.deserialize_identifier(GeneratedVisitor)
10113            }
10114        }
10115        struct GeneratedVisitor;
10116        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10117            type Value = StopMutation;
10118
10119            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10120                formatter.write_str("struct stream_plan.StopMutation")
10121            }
10122
10123            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StopMutation, V::Error>
10124                where
10125                    V: serde::de::MapAccess<'de>,
10126            {
10127                let mut actors__ = None;
10128                let mut dropped_sink_fragments__ = None;
10129                while let Some(k) = map_.next_key()? {
10130                    match k {
10131                        GeneratedField::Actors => {
10132                            if actors__.is_some() {
10133                                return Err(serde::de::Error::duplicate_field("actors"));
10134                            }
10135                            actors__ = 
10136                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10137                                    .into_iter().map(|x| x.0).collect())
10138                            ;
10139                        }
10140                        GeneratedField::DroppedSinkFragments => {
10141                            if dropped_sink_fragments__.is_some() {
10142                                return Err(serde::de::Error::duplicate_field("droppedSinkFragments"));
10143                            }
10144                            dropped_sink_fragments__ = 
10145                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10146                                    .into_iter().map(|x| x.0).collect())
10147                            ;
10148                        }
10149                    }
10150                }
10151                Ok(StopMutation {
10152                    actors: actors__.unwrap_or_default(),
10153                    dropped_sink_fragments: dropped_sink_fragments__.unwrap_or_default(),
10154                })
10155            }
10156        }
10157        deserializer.deserialize_struct("stream_plan.StopMutation", FIELDS, GeneratedVisitor)
10158    }
10159}
10160impl serde::Serialize for StreamActor {
10161    #[allow(deprecated)]
10162    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10163    where
10164        S: serde::Serializer,
10165    {
10166        use serde::ser::SerializeStruct;
10167        let mut len = 0;
10168        if self.actor_id != 0 {
10169            len += 1;
10170        }
10171        if self.fragment_id != 0 {
10172            len += 1;
10173        }
10174        if !self.dispatcher.is_empty() {
10175            len += 1;
10176        }
10177        if self.vnode_bitmap.is_some() {
10178            len += 1;
10179        }
10180        if !self.mview_definition.is_empty() {
10181            len += 1;
10182        }
10183        if self.expr_context.is_some() {
10184            len += 1;
10185        }
10186        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamActor", len)?;
10187        if self.actor_id != 0 {
10188            struct_ser.serialize_field("actorId", &self.actor_id)?;
10189        }
10190        if self.fragment_id != 0 {
10191            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
10192        }
10193        if !self.dispatcher.is_empty() {
10194            struct_ser.serialize_field("dispatcher", &self.dispatcher)?;
10195        }
10196        if let Some(v) = self.vnode_bitmap.as_ref() {
10197            struct_ser.serialize_field("vnodeBitmap", v)?;
10198        }
10199        if !self.mview_definition.is_empty() {
10200            struct_ser.serialize_field("mviewDefinition", &self.mview_definition)?;
10201        }
10202        if let Some(v) = self.expr_context.as_ref() {
10203            struct_ser.serialize_field("exprContext", v)?;
10204        }
10205        struct_ser.end()
10206    }
10207}
10208impl<'de> serde::Deserialize<'de> for StreamActor {
10209    #[allow(deprecated)]
10210    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10211    where
10212        D: serde::Deserializer<'de>,
10213    {
10214        const FIELDS: &[&str] = &[
10215            "actor_id",
10216            "actorId",
10217            "fragment_id",
10218            "fragmentId",
10219            "dispatcher",
10220            "vnode_bitmap",
10221            "vnodeBitmap",
10222            "mview_definition",
10223            "mviewDefinition",
10224            "expr_context",
10225            "exprContext",
10226        ];
10227
10228        #[allow(clippy::enum_variant_names)]
10229        enum GeneratedField {
10230            ActorId,
10231            FragmentId,
10232            Dispatcher,
10233            VnodeBitmap,
10234            MviewDefinition,
10235            ExprContext,
10236        }
10237        impl<'de> serde::Deserialize<'de> for GeneratedField {
10238            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10239            where
10240                D: serde::Deserializer<'de>,
10241            {
10242                struct GeneratedVisitor;
10243
10244                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10245                    type Value = GeneratedField;
10246
10247                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10248                        write!(formatter, "expected one of: {:?}", &FIELDS)
10249                    }
10250
10251                    #[allow(unused_variables)]
10252                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10253                    where
10254                        E: serde::de::Error,
10255                    {
10256                        match value {
10257                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
10258                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
10259                            "dispatcher" => Ok(GeneratedField::Dispatcher),
10260                            "vnodeBitmap" | "vnode_bitmap" => Ok(GeneratedField::VnodeBitmap),
10261                            "mviewDefinition" | "mview_definition" => Ok(GeneratedField::MviewDefinition),
10262                            "exprContext" | "expr_context" => Ok(GeneratedField::ExprContext),
10263                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10264                        }
10265                    }
10266                }
10267                deserializer.deserialize_identifier(GeneratedVisitor)
10268            }
10269        }
10270        struct GeneratedVisitor;
10271        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10272            type Value = StreamActor;
10273
10274            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10275                formatter.write_str("struct stream_plan.StreamActor")
10276            }
10277
10278            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamActor, V::Error>
10279                where
10280                    V: serde::de::MapAccess<'de>,
10281            {
10282                let mut actor_id__ = None;
10283                let mut fragment_id__ = None;
10284                let mut dispatcher__ = None;
10285                let mut vnode_bitmap__ = None;
10286                let mut mview_definition__ = None;
10287                let mut expr_context__ = None;
10288                while let Some(k) = map_.next_key()? {
10289                    match k {
10290                        GeneratedField::ActorId => {
10291                            if actor_id__.is_some() {
10292                                return Err(serde::de::Error::duplicate_field("actorId"));
10293                            }
10294                            actor_id__ = 
10295                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10296                            ;
10297                        }
10298                        GeneratedField::FragmentId => {
10299                            if fragment_id__.is_some() {
10300                                return Err(serde::de::Error::duplicate_field("fragmentId"));
10301                            }
10302                            fragment_id__ = 
10303                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10304                            ;
10305                        }
10306                        GeneratedField::Dispatcher => {
10307                            if dispatcher__.is_some() {
10308                                return Err(serde::de::Error::duplicate_field("dispatcher"));
10309                            }
10310                            dispatcher__ = Some(map_.next_value()?);
10311                        }
10312                        GeneratedField::VnodeBitmap => {
10313                            if vnode_bitmap__.is_some() {
10314                                return Err(serde::de::Error::duplicate_field("vnodeBitmap"));
10315                            }
10316                            vnode_bitmap__ = map_.next_value()?;
10317                        }
10318                        GeneratedField::MviewDefinition => {
10319                            if mview_definition__.is_some() {
10320                                return Err(serde::de::Error::duplicate_field("mviewDefinition"));
10321                            }
10322                            mview_definition__ = Some(map_.next_value()?);
10323                        }
10324                        GeneratedField::ExprContext => {
10325                            if expr_context__.is_some() {
10326                                return Err(serde::de::Error::duplicate_field("exprContext"));
10327                            }
10328                            expr_context__ = map_.next_value()?;
10329                        }
10330                    }
10331                }
10332                Ok(StreamActor {
10333                    actor_id: actor_id__.unwrap_or_default(),
10334                    fragment_id: fragment_id__.unwrap_or_default(),
10335                    dispatcher: dispatcher__.unwrap_or_default(),
10336                    vnode_bitmap: vnode_bitmap__,
10337                    mview_definition: mview_definition__.unwrap_or_default(),
10338                    expr_context: expr_context__,
10339                })
10340            }
10341        }
10342        deserializer.deserialize_struct("stream_plan.StreamActor", FIELDS, GeneratedVisitor)
10343    }
10344}
10345impl serde::Serialize for StreamCdcScanNode {
10346    #[allow(deprecated)]
10347    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10348    where
10349        S: serde::Serializer,
10350    {
10351        use serde::ser::SerializeStruct;
10352        let mut len = 0;
10353        if self.table_id != 0 {
10354            len += 1;
10355        }
10356        if !self.upstream_column_ids.is_empty() {
10357            len += 1;
10358        }
10359        if !self.output_indices.is_empty() {
10360            len += 1;
10361        }
10362        if self.state_table.is_some() {
10363            len += 1;
10364        }
10365        if self.cdc_table_desc.is_some() {
10366            len += 1;
10367        }
10368        if self.rate_limit.is_some() {
10369            len += 1;
10370        }
10371        if self.disable_backfill {
10372            len += 1;
10373        }
10374        if self.options.is_some() {
10375            len += 1;
10376        }
10377        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanNode", len)?;
10378        if self.table_id != 0 {
10379            struct_ser.serialize_field("tableId", &self.table_id)?;
10380        }
10381        if !self.upstream_column_ids.is_empty() {
10382            struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
10383        }
10384        if !self.output_indices.is_empty() {
10385            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
10386        }
10387        if let Some(v) = self.state_table.as_ref() {
10388            struct_ser.serialize_field("stateTable", v)?;
10389        }
10390        if let Some(v) = self.cdc_table_desc.as_ref() {
10391            struct_ser.serialize_field("cdcTableDesc", v)?;
10392        }
10393        if let Some(v) = self.rate_limit.as_ref() {
10394            struct_ser.serialize_field("rateLimit", v)?;
10395        }
10396        if self.disable_backfill {
10397            struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
10398        }
10399        if let Some(v) = self.options.as_ref() {
10400            struct_ser.serialize_field("options", v)?;
10401        }
10402        struct_ser.end()
10403    }
10404}
10405impl<'de> serde::Deserialize<'de> for StreamCdcScanNode {
10406    #[allow(deprecated)]
10407    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10408    where
10409        D: serde::Deserializer<'de>,
10410    {
10411        const FIELDS: &[&str] = &[
10412            "table_id",
10413            "tableId",
10414            "upstream_column_ids",
10415            "upstreamColumnIds",
10416            "output_indices",
10417            "outputIndices",
10418            "state_table",
10419            "stateTable",
10420            "cdc_table_desc",
10421            "cdcTableDesc",
10422            "rate_limit",
10423            "rateLimit",
10424            "disable_backfill",
10425            "disableBackfill",
10426            "options",
10427        ];
10428
10429        #[allow(clippy::enum_variant_names)]
10430        enum GeneratedField {
10431            TableId,
10432            UpstreamColumnIds,
10433            OutputIndices,
10434            StateTable,
10435            CdcTableDesc,
10436            RateLimit,
10437            DisableBackfill,
10438            Options,
10439        }
10440        impl<'de> serde::Deserialize<'de> for GeneratedField {
10441            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10442            where
10443                D: serde::Deserializer<'de>,
10444            {
10445                struct GeneratedVisitor;
10446
10447                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10448                    type Value = GeneratedField;
10449
10450                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10451                        write!(formatter, "expected one of: {:?}", &FIELDS)
10452                    }
10453
10454                    #[allow(unused_variables)]
10455                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10456                    where
10457                        E: serde::de::Error,
10458                    {
10459                        match value {
10460                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
10461                            "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
10462                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
10463                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
10464                            "cdcTableDesc" | "cdc_table_desc" => Ok(GeneratedField::CdcTableDesc),
10465                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
10466                            "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
10467                            "options" => Ok(GeneratedField::Options),
10468                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10469                        }
10470                    }
10471                }
10472                deserializer.deserialize_identifier(GeneratedVisitor)
10473            }
10474        }
10475        struct GeneratedVisitor;
10476        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10477            type Value = StreamCdcScanNode;
10478
10479            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10480                formatter.write_str("struct stream_plan.StreamCdcScanNode")
10481            }
10482
10483            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanNode, V::Error>
10484                where
10485                    V: serde::de::MapAccess<'de>,
10486            {
10487                let mut table_id__ = None;
10488                let mut upstream_column_ids__ = None;
10489                let mut output_indices__ = None;
10490                let mut state_table__ = None;
10491                let mut cdc_table_desc__ = None;
10492                let mut rate_limit__ = None;
10493                let mut disable_backfill__ = None;
10494                let mut options__ = None;
10495                while let Some(k) = map_.next_key()? {
10496                    match k {
10497                        GeneratedField::TableId => {
10498                            if table_id__.is_some() {
10499                                return Err(serde::de::Error::duplicate_field("tableId"));
10500                            }
10501                            table_id__ = 
10502                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10503                            ;
10504                        }
10505                        GeneratedField::UpstreamColumnIds => {
10506                            if upstream_column_ids__.is_some() {
10507                                return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
10508                            }
10509                            upstream_column_ids__ = 
10510                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10511                                    .into_iter().map(|x| x.0).collect())
10512                            ;
10513                        }
10514                        GeneratedField::OutputIndices => {
10515                            if output_indices__.is_some() {
10516                                return Err(serde::de::Error::duplicate_field("outputIndices"));
10517                            }
10518                            output_indices__ = 
10519                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
10520                                    .into_iter().map(|x| x.0).collect())
10521                            ;
10522                        }
10523                        GeneratedField::StateTable => {
10524                            if state_table__.is_some() {
10525                                return Err(serde::de::Error::duplicate_field("stateTable"));
10526                            }
10527                            state_table__ = map_.next_value()?;
10528                        }
10529                        GeneratedField::CdcTableDesc => {
10530                            if cdc_table_desc__.is_some() {
10531                                return Err(serde::de::Error::duplicate_field("cdcTableDesc"));
10532                            }
10533                            cdc_table_desc__ = map_.next_value()?;
10534                        }
10535                        GeneratedField::RateLimit => {
10536                            if rate_limit__.is_some() {
10537                                return Err(serde::de::Error::duplicate_field("rateLimit"));
10538                            }
10539                            rate_limit__ = 
10540                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
10541                            ;
10542                        }
10543                        GeneratedField::DisableBackfill => {
10544                            if disable_backfill__.is_some() {
10545                                return Err(serde::de::Error::duplicate_field("disableBackfill"));
10546                            }
10547                            disable_backfill__ = Some(map_.next_value()?);
10548                        }
10549                        GeneratedField::Options => {
10550                            if options__.is_some() {
10551                                return Err(serde::de::Error::duplicate_field("options"));
10552                            }
10553                            options__ = map_.next_value()?;
10554                        }
10555                    }
10556                }
10557                Ok(StreamCdcScanNode {
10558                    table_id: table_id__.unwrap_or_default(),
10559                    upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
10560                    output_indices: output_indices__.unwrap_or_default(),
10561                    state_table: state_table__,
10562                    cdc_table_desc: cdc_table_desc__,
10563                    rate_limit: rate_limit__,
10564                    disable_backfill: disable_backfill__.unwrap_or_default(),
10565                    options: options__,
10566                })
10567            }
10568        }
10569        deserializer.deserialize_struct("stream_plan.StreamCdcScanNode", FIELDS, GeneratedVisitor)
10570    }
10571}
10572impl serde::Serialize for StreamCdcScanOptions {
10573    #[allow(deprecated)]
10574    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10575    where
10576        S: serde::Serializer,
10577    {
10578        use serde::ser::SerializeStruct;
10579        let mut len = 0;
10580        if self.disable_backfill {
10581            len += 1;
10582        }
10583        if self.snapshot_barrier_interval != 0 {
10584            len += 1;
10585        }
10586        if self.snapshot_batch_size != 0 {
10587            len += 1;
10588        }
10589        if self.backfill_parallelism != 0 {
10590            len += 1;
10591        }
10592        if self.backfill_num_rows_per_split != 0 {
10593            len += 1;
10594        }
10595        if self.backfill_as_even_splits {
10596            len += 1;
10597        }
10598        if self.backfill_split_pk_column_index != 0 {
10599            len += 1;
10600        }
10601        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamCdcScanOptions", len)?;
10602        if self.disable_backfill {
10603            struct_ser.serialize_field("disableBackfill", &self.disable_backfill)?;
10604        }
10605        if self.snapshot_barrier_interval != 0 {
10606            struct_ser.serialize_field("snapshotBarrierInterval", &self.snapshot_barrier_interval)?;
10607        }
10608        if self.snapshot_batch_size != 0 {
10609            struct_ser.serialize_field("snapshotBatchSize", &self.snapshot_batch_size)?;
10610        }
10611        if self.backfill_parallelism != 0 {
10612            struct_ser.serialize_field("backfillParallelism", &self.backfill_parallelism)?;
10613        }
10614        if self.backfill_num_rows_per_split != 0 {
10615            #[allow(clippy::needless_borrow)]
10616            #[allow(clippy::needless_borrows_for_generic_args)]
10617            struct_ser.serialize_field("backfillNumRowsPerSplit", ToString::to_string(&self.backfill_num_rows_per_split).as_str())?;
10618        }
10619        if self.backfill_as_even_splits {
10620            struct_ser.serialize_field("backfillAsEvenSplits", &self.backfill_as_even_splits)?;
10621        }
10622        if self.backfill_split_pk_column_index != 0 {
10623            struct_ser.serialize_field("backfillSplitPkColumnIndex", &self.backfill_split_pk_column_index)?;
10624        }
10625        struct_ser.end()
10626    }
10627}
10628impl<'de> serde::Deserialize<'de> for StreamCdcScanOptions {
10629    #[allow(deprecated)]
10630    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10631    where
10632        D: serde::Deserializer<'de>,
10633    {
10634        const FIELDS: &[&str] = &[
10635            "disable_backfill",
10636            "disableBackfill",
10637            "snapshot_barrier_interval",
10638            "snapshotBarrierInterval",
10639            "snapshot_batch_size",
10640            "snapshotBatchSize",
10641            "backfill_parallelism",
10642            "backfillParallelism",
10643            "backfill_num_rows_per_split",
10644            "backfillNumRowsPerSplit",
10645            "backfill_as_even_splits",
10646            "backfillAsEvenSplits",
10647            "backfill_split_pk_column_index",
10648            "backfillSplitPkColumnIndex",
10649        ];
10650
10651        #[allow(clippy::enum_variant_names)]
10652        enum GeneratedField {
10653            DisableBackfill,
10654            SnapshotBarrierInterval,
10655            SnapshotBatchSize,
10656            BackfillParallelism,
10657            BackfillNumRowsPerSplit,
10658            BackfillAsEvenSplits,
10659            BackfillSplitPkColumnIndex,
10660        }
10661        impl<'de> serde::Deserialize<'de> for GeneratedField {
10662            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10663            where
10664                D: serde::Deserializer<'de>,
10665            {
10666                struct GeneratedVisitor;
10667
10668                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10669                    type Value = GeneratedField;
10670
10671                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10672                        write!(formatter, "expected one of: {:?}", &FIELDS)
10673                    }
10674
10675                    #[allow(unused_variables)]
10676                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10677                    where
10678                        E: serde::de::Error,
10679                    {
10680                        match value {
10681                            "disableBackfill" | "disable_backfill" => Ok(GeneratedField::DisableBackfill),
10682                            "snapshotBarrierInterval" | "snapshot_barrier_interval" => Ok(GeneratedField::SnapshotBarrierInterval),
10683                            "snapshotBatchSize" | "snapshot_batch_size" => Ok(GeneratedField::SnapshotBatchSize),
10684                            "backfillParallelism" | "backfill_parallelism" => Ok(GeneratedField::BackfillParallelism),
10685                            "backfillNumRowsPerSplit" | "backfill_num_rows_per_split" => Ok(GeneratedField::BackfillNumRowsPerSplit),
10686                            "backfillAsEvenSplits" | "backfill_as_even_splits" => Ok(GeneratedField::BackfillAsEvenSplits),
10687                            "backfillSplitPkColumnIndex" | "backfill_split_pk_column_index" => Ok(GeneratedField::BackfillSplitPkColumnIndex),
10688                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10689                        }
10690                    }
10691                }
10692                deserializer.deserialize_identifier(GeneratedVisitor)
10693            }
10694        }
10695        struct GeneratedVisitor;
10696        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10697            type Value = StreamCdcScanOptions;
10698
10699            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10700                formatter.write_str("struct stream_plan.StreamCdcScanOptions")
10701            }
10702
10703            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamCdcScanOptions, V::Error>
10704                where
10705                    V: serde::de::MapAccess<'de>,
10706            {
10707                let mut disable_backfill__ = None;
10708                let mut snapshot_barrier_interval__ = None;
10709                let mut snapshot_batch_size__ = None;
10710                let mut backfill_parallelism__ = None;
10711                let mut backfill_num_rows_per_split__ = None;
10712                let mut backfill_as_even_splits__ = None;
10713                let mut backfill_split_pk_column_index__ = None;
10714                while let Some(k) = map_.next_key()? {
10715                    match k {
10716                        GeneratedField::DisableBackfill => {
10717                            if disable_backfill__.is_some() {
10718                                return Err(serde::de::Error::duplicate_field("disableBackfill"));
10719                            }
10720                            disable_backfill__ = Some(map_.next_value()?);
10721                        }
10722                        GeneratedField::SnapshotBarrierInterval => {
10723                            if snapshot_barrier_interval__.is_some() {
10724                                return Err(serde::de::Error::duplicate_field("snapshotBarrierInterval"));
10725                            }
10726                            snapshot_barrier_interval__ = 
10727                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10728                            ;
10729                        }
10730                        GeneratedField::SnapshotBatchSize => {
10731                            if snapshot_batch_size__.is_some() {
10732                                return Err(serde::de::Error::duplicate_field("snapshotBatchSize"));
10733                            }
10734                            snapshot_batch_size__ = 
10735                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10736                            ;
10737                        }
10738                        GeneratedField::BackfillParallelism => {
10739                            if backfill_parallelism__.is_some() {
10740                                return Err(serde::de::Error::duplicate_field("backfillParallelism"));
10741                            }
10742                            backfill_parallelism__ = 
10743                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10744                            ;
10745                        }
10746                        GeneratedField::BackfillNumRowsPerSplit => {
10747                            if backfill_num_rows_per_split__.is_some() {
10748                                return Err(serde::de::Error::duplicate_field("backfillNumRowsPerSplit"));
10749                            }
10750                            backfill_num_rows_per_split__ = 
10751                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10752                            ;
10753                        }
10754                        GeneratedField::BackfillAsEvenSplits => {
10755                            if backfill_as_even_splits__.is_some() {
10756                                return Err(serde::de::Error::duplicate_field("backfillAsEvenSplits"));
10757                            }
10758                            backfill_as_even_splits__ = Some(map_.next_value()?);
10759                        }
10760                        GeneratedField::BackfillSplitPkColumnIndex => {
10761                            if backfill_split_pk_column_index__.is_some() {
10762                                return Err(serde::de::Error::duplicate_field("backfillSplitPkColumnIndex"));
10763                            }
10764                            backfill_split_pk_column_index__ = 
10765                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
10766                            ;
10767                        }
10768                    }
10769                }
10770                Ok(StreamCdcScanOptions {
10771                    disable_backfill: disable_backfill__.unwrap_or_default(),
10772                    snapshot_barrier_interval: snapshot_barrier_interval__.unwrap_or_default(),
10773                    snapshot_batch_size: snapshot_batch_size__.unwrap_or_default(),
10774                    backfill_parallelism: backfill_parallelism__.unwrap_or_default(),
10775                    backfill_num_rows_per_split: backfill_num_rows_per_split__.unwrap_or_default(),
10776                    backfill_as_even_splits: backfill_as_even_splits__.unwrap_or_default(),
10777                    backfill_split_pk_column_index: backfill_split_pk_column_index__.unwrap_or_default(),
10778                })
10779            }
10780        }
10781        deserializer.deserialize_struct("stream_plan.StreamCdcScanOptions", FIELDS, GeneratedVisitor)
10782    }
10783}
10784impl serde::Serialize for StreamContext {
10785    #[allow(deprecated)]
10786    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10787    where
10788        S: serde::Serializer,
10789    {
10790        use serde::ser::SerializeStruct;
10791        let mut len = 0;
10792        if !self.timezone.is_empty() {
10793            len += 1;
10794        }
10795        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamContext", len)?;
10796        if !self.timezone.is_empty() {
10797            struct_ser.serialize_field("timezone", &self.timezone)?;
10798        }
10799        struct_ser.end()
10800    }
10801}
10802impl<'de> serde::Deserialize<'de> for StreamContext {
10803    #[allow(deprecated)]
10804    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
10805    where
10806        D: serde::Deserializer<'de>,
10807    {
10808        const FIELDS: &[&str] = &[
10809            "timezone",
10810        ];
10811
10812        #[allow(clippy::enum_variant_names)]
10813        enum GeneratedField {
10814            Timezone,
10815        }
10816        impl<'de> serde::Deserialize<'de> for GeneratedField {
10817            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10818            where
10819                D: serde::Deserializer<'de>,
10820            {
10821                struct GeneratedVisitor;
10822
10823                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10824                    type Value = GeneratedField;
10825
10826                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10827                        write!(formatter, "expected one of: {:?}", &FIELDS)
10828                    }
10829
10830                    #[allow(unused_variables)]
10831                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10832                    where
10833                        E: serde::de::Error,
10834                    {
10835                        match value {
10836                            "timezone" => Ok(GeneratedField::Timezone),
10837                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10838                        }
10839                    }
10840                }
10841                deserializer.deserialize_identifier(GeneratedVisitor)
10842            }
10843        }
10844        struct GeneratedVisitor;
10845        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10846            type Value = StreamContext;
10847
10848            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10849                formatter.write_str("struct stream_plan.StreamContext")
10850            }
10851
10852            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamContext, V::Error>
10853                where
10854                    V: serde::de::MapAccess<'de>,
10855            {
10856                let mut timezone__ = None;
10857                while let Some(k) = map_.next_key()? {
10858                    match k {
10859                        GeneratedField::Timezone => {
10860                            if timezone__.is_some() {
10861                                return Err(serde::de::Error::duplicate_field("timezone"));
10862                            }
10863                            timezone__ = Some(map_.next_value()?);
10864                        }
10865                    }
10866                }
10867                Ok(StreamContext {
10868                    timezone: timezone__.unwrap_or_default(),
10869                })
10870            }
10871        }
10872        deserializer.deserialize_struct("stream_plan.StreamContext", FIELDS, GeneratedVisitor)
10873    }
10874}
10875impl serde::Serialize for StreamFragmentGraph {
10876    #[allow(deprecated)]
10877    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
10878    where
10879        S: serde::Serializer,
10880    {
10881        use serde::ser::SerializeStruct;
10882        let mut len = 0;
10883        if !self.fragments.is_empty() {
10884            len += 1;
10885        }
10886        if !self.edges.is_empty() {
10887            len += 1;
10888        }
10889        if !self.dependent_table_ids.is_empty() {
10890            len += 1;
10891        }
10892        if self.table_ids_cnt != 0 {
10893            len += 1;
10894        }
10895        if self.ctx.is_some() {
10896            len += 1;
10897        }
10898        if self.parallelism.is_some() {
10899            len += 1;
10900        }
10901        if self.max_parallelism != 0 {
10902            len += 1;
10903        }
10904        if self.backfill_order.is_some() {
10905            len += 1;
10906        }
10907        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph", len)?;
10908        if !self.fragments.is_empty() {
10909            struct_ser.serialize_field("fragments", &self.fragments)?;
10910        }
10911        if !self.edges.is_empty() {
10912            struct_ser.serialize_field("edges", &self.edges)?;
10913        }
10914        if !self.dependent_table_ids.is_empty() {
10915            struct_ser.serialize_field("dependentTableIds", &self.dependent_table_ids)?;
10916        }
10917        if self.table_ids_cnt != 0 {
10918            struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
10919        }
10920        if let Some(v) = self.ctx.as_ref() {
10921            struct_ser.serialize_field("ctx", v)?;
10922        }
10923        if let Some(v) = self.parallelism.as_ref() {
10924            struct_ser.serialize_field("parallelism", v)?;
10925        }
10926        if self.max_parallelism != 0 {
10927            struct_ser.serialize_field("maxParallelism", &self.max_parallelism)?;
10928        }
10929        if let Some(v) = self.backfill_order.as_ref() {
10930            struct_ser.serialize_field("backfillOrder", v)?;
10931        }
10932        struct_ser.end()
10933    }
10934}
10935impl<'de> serde::Deserialize<'de> for StreamFragmentGraph {
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            "fragments",
10943            "edges",
10944            "dependent_table_ids",
10945            "dependentTableIds",
10946            "table_ids_cnt",
10947            "tableIdsCnt",
10948            "ctx",
10949            "parallelism",
10950            "max_parallelism",
10951            "maxParallelism",
10952            "backfill_order",
10953            "backfillOrder",
10954        ];
10955
10956        #[allow(clippy::enum_variant_names)]
10957        enum GeneratedField {
10958            Fragments,
10959            Edges,
10960            DependentTableIds,
10961            TableIdsCnt,
10962            Ctx,
10963            Parallelism,
10964            MaxParallelism,
10965            BackfillOrder,
10966        }
10967        impl<'de> serde::Deserialize<'de> for GeneratedField {
10968            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
10969            where
10970                D: serde::Deserializer<'de>,
10971            {
10972                struct GeneratedVisitor;
10973
10974                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
10975                    type Value = GeneratedField;
10976
10977                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
10978                        write!(formatter, "expected one of: {:?}", &FIELDS)
10979                    }
10980
10981                    #[allow(unused_variables)]
10982                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
10983                    where
10984                        E: serde::de::Error,
10985                    {
10986                        match value {
10987                            "fragments" => Ok(GeneratedField::Fragments),
10988                            "edges" => Ok(GeneratedField::Edges),
10989                            "dependentTableIds" | "dependent_table_ids" => Ok(GeneratedField::DependentTableIds),
10990                            "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
10991                            "ctx" => Ok(GeneratedField::Ctx),
10992                            "parallelism" => Ok(GeneratedField::Parallelism),
10993                            "maxParallelism" | "max_parallelism" => Ok(GeneratedField::MaxParallelism),
10994                            "backfillOrder" | "backfill_order" => Ok(GeneratedField::BackfillOrder),
10995                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
10996                        }
10997                    }
10998                }
10999                deserializer.deserialize_identifier(GeneratedVisitor)
11000            }
11001        }
11002        struct GeneratedVisitor;
11003        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11004            type Value = StreamFragmentGraph;
11005
11006            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11007                formatter.write_str("struct stream_plan.StreamFragmentGraph")
11008            }
11009
11010            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFragmentGraph, V::Error>
11011                where
11012                    V: serde::de::MapAccess<'de>,
11013            {
11014                let mut fragments__ = None;
11015                let mut edges__ = None;
11016                let mut dependent_table_ids__ = None;
11017                let mut table_ids_cnt__ = None;
11018                let mut ctx__ = None;
11019                let mut parallelism__ = None;
11020                let mut max_parallelism__ = None;
11021                let mut backfill_order__ = None;
11022                while let Some(k) = map_.next_key()? {
11023                    match k {
11024                        GeneratedField::Fragments => {
11025                            if fragments__.is_some() {
11026                                return Err(serde::de::Error::duplicate_field("fragments"));
11027                            }
11028                            fragments__ = Some(
11029                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
11030                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
11031                            );
11032                        }
11033                        GeneratedField::Edges => {
11034                            if edges__.is_some() {
11035                                return Err(serde::de::Error::duplicate_field("edges"));
11036                            }
11037                            edges__ = Some(map_.next_value()?);
11038                        }
11039                        GeneratedField::DependentTableIds => {
11040                            if dependent_table_ids__.is_some() {
11041                                return Err(serde::de::Error::duplicate_field("dependentTableIds"));
11042                            }
11043                            dependent_table_ids__ = 
11044                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11045                                    .into_iter().map(|x| x.0).collect())
11046                            ;
11047                        }
11048                        GeneratedField::TableIdsCnt => {
11049                            if table_ids_cnt__.is_some() {
11050                                return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
11051                            }
11052                            table_ids_cnt__ = 
11053                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11054                            ;
11055                        }
11056                        GeneratedField::Ctx => {
11057                            if ctx__.is_some() {
11058                                return Err(serde::de::Error::duplicate_field("ctx"));
11059                            }
11060                            ctx__ = map_.next_value()?;
11061                        }
11062                        GeneratedField::Parallelism => {
11063                            if parallelism__.is_some() {
11064                                return Err(serde::de::Error::duplicate_field("parallelism"));
11065                            }
11066                            parallelism__ = map_.next_value()?;
11067                        }
11068                        GeneratedField::MaxParallelism => {
11069                            if max_parallelism__.is_some() {
11070                                return Err(serde::de::Error::duplicate_field("maxParallelism"));
11071                            }
11072                            max_parallelism__ = 
11073                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11074                            ;
11075                        }
11076                        GeneratedField::BackfillOrder => {
11077                            if backfill_order__.is_some() {
11078                                return Err(serde::de::Error::duplicate_field("backfillOrder"));
11079                            }
11080                            backfill_order__ = map_.next_value()?;
11081                        }
11082                    }
11083                }
11084                Ok(StreamFragmentGraph {
11085                    fragments: fragments__.unwrap_or_default(),
11086                    edges: edges__.unwrap_or_default(),
11087                    dependent_table_ids: dependent_table_ids__.unwrap_or_default(),
11088                    table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
11089                    ctx: ctx__,
11090                    parallelism: parallelism__,
11091                    max_parallelism: max_parallelism__.unwrap_or_default(),
11092                    backfill_order: backfill_order__,
11093                })
11094            }
11095        }
11096        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph", FIELDS, GeneratedVisitor)
11097    }
11098}
11099impl serde::Serialize for stream_fragment_graph::Parallelism {
11100    #[allow(deprecated)]
11101    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11102    where
11103        S: serde::Serializer,
11104    {
11105        use serde::ser::SerializeStruct;
11106        let mut len = 0;
11107        if self.parallelism != 0 {
11108            len += 1;
11109        }
11110        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.Parallelism", len)?;
11111        if self.parallelism != 0 {
11112            #[allow(clippy::needless_borrow)]
11113            #[allow(clippy::needless_borrows_for_generic_args)]
11114            struct_ser.serialize_field("parallelism", ToString::to_string(&self.parallelism).as_str())?;
11115        }
11116        struct_ser.end()
11117    }
11118}
11119impl<'de> serde::Deserialize<'de> for stream_fragment_graph::Parallelism {
11120    #[allow(deprecated)]
11121    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11122    where
11123        D: serde::Deserializer<'de>,
11124    {
11125        const FIELDS: &[&str] = &[
11126            "parallelism",
11127        ];
11128
11129        #[allow(clippy::enum_variant_names)]
11130        enum GeneratedField {
11131            Parallelism,
11132        }
11133        impl<'de> serde::Deserialize<'de> for GeneratedField {
11134            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11135            where
11136                D: serde::Deserializer<'de>,
11137            {
11138                struct GeneratedVisitor;
11139
11140                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11141                    type Value = GeneratedField;
11142
11143                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11144                        write!(formatter, "expected one of: {:?}", &FIELDS)
11145                    }
11146
11147                    #[allow(unused_variables)]
11148                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11149                    where
11150                        E: serde::de::Error,
11151                    {
11152                        match value {
11153                            "parallelism" => Ok(GeneratedField::Parallelism),
11154                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11155                        }
11156                    }
11157                }
11158                deserializer.deserialize_identifier(GeneratedVisitor)
11159            }
11160        }
11161        struct GeneratedVisitor;
11162        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11163            type Value = stream_fragment_graph::Parallelism;
11164
11165            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11166                formatter.write_str("struct stream_plan.StreamFragmentGraph.Parallelism")
11167            }
11168
11169            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::Parallelism, V::Error>
11170                where
11171                    V: serde::de::MapAccess<'de>,
11172            {
11173                let mut parallelism__ = None;
11174                while let Some(k) = map_.next_key()? {
11175                    match k {
11176                        GeneratedField::Parallelism => {
11177                            if parallelism__.is_some() {
11178                                return Err(serde::de::Error::duplicate_field("parallelism"));
11179                            }
11180                            parallelism__ = 
11181                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11182                            ;
11183                        }
11184                    }
11185                }
11186                Ok(stream_fragment_graph::Parallelism {
11187                    parallelism: parallelism__.unwrap_or_default(),
11188                })
11189            }
11190        }
11191        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.Parallelism", FIELDS, GeneratedVisitor)
11192    }
11193}
11194impl serde::Serialize for stream_fragment_graph::StreamFragment {
11195    #[allow(deprecated)]
11196    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11197    where
11198        S: serde::Serializer,
11199    {
11200        use serde::ser::SerializeStruct;
11201        let mut len = 0;
11202        if self.fragment_id != 0 {
11203            len += 1;
11204        }
11205        if self.node.is_some() {
11206            len += 1;
11207        }
11208        if self.fragment_type_mask != 0 {
11209            len += 1;
11210        }
11211        if self.requires_singleton {
11212            len += 1;
11213        }
11214        if self.table_ids_cnt != 0 {
11215            len += 1;
11216        }
11217        if !self.upstream_table_ids.is_empty() {
11218            len += 1;
11219        }
11220        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", len)?;
11221        if self.fragment_id != 0 {
11222            struct_ser.serialize_field("fragmentId", &self.fragment_id)?;
11223        }
11224        if let Some(v) = self.node.as_ref() {
11225            struct_ser.serialize_field("node", v)?;
11226        }
11227        if self.fragment_type_mask != 0 {
11228            struct_ser.serialize_field("fragmentTypeMask", &self.fragment_type_mask)?;
11229        }
11230        if self.requires_singleton {
11231            struct_ser.serialize_field("requiresSingleton", &self.requires_singleton)?;
11232        }
11233        if self.table_ids_cnt != 0 {
11234            struct_ser.serialize_field("tableIdsCnt", &self.table_ids_cnt)?;
11235        }
11236        if !self.upstream_table_ids.is_empty() {
11237            struct_ser.serialize_field("upstreamTableIds", &self.upstream_table_ids)?;
11238        }
11239        struct_ser.end()
11240    }
11241}
11242impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragment {
11243    #[allow(deprecated)]
11244    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11245    where
11246        D: serde::Deserializer<'de>,
11247    {
11248        const FIELDS: &[&str] = &[
11249            "fragment_id",
11250            "fragmentId",
11251            "node",
11252            "fragment_type_mask",
11253            "fragmentTypeMask",
11254            "requires_singleton",
11255            "requiresSingleton",
11256            "table_ids_cnt",
11257            "tableIdsCnt",
11258            "upstream_table_ids",
11259            "upstreamTableIds",
11260        ];
11261
11262        #[allow(clippy::enum_variant_names)]
11263        enum GeneratedField {
11264            FragmentId,
11265            Node,
11266            FragmentTypeMask,
11267            RequiresSingleton,
11268            TableIdsCnt,
11269            UpstreamTableIds,
11270        }
11271        impl<'de> serde::Deserialize<'de> for GeneratedField {
11272            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11273            where
11274                D: serde::Deserializer<'de>,
11275            {
11276                struct GeneratedVisitor;
11277
11278                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11279                    type Value = GeneratedField;
11280
11281                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11282                        write!(formatter, "expected one of: {:?}", &FIELDS)
11283                    }
11284
11285                    #[allow(unused_variables)]
11286                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11287                    where
11288                        E: serde::de::Error,
11289                    {
11290                        match value {
11291                            "fragmentId" | "fragment_id" => Ok(GeneratedField::FragmentId),
11292                            "node" => Ok(GeneratedField::Node),
11293                            "fragmentTypeMask" | "fragment_type_mask" => Ok(GeneratedField::FragmentTypeMask),
11294                            "requiresSingleton" | "requires_singleton" => Ok(GeneratedField::RequiresSingleton),
11295                            "tableIdsCnt" | "table_ids_cnt" => Ok(GeneratedField::TableIdsCnt),
11296                            "upstreamTableIds" | "upstream_table_ids" => Ok(GeneratedField::UpstreamTableIds),
11297                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11298                        }
11299                    }
11300                }
11301                deserializer.deserialize_identifier(GeneratedVisitor)
11302            }
11303        }
11304        struct GeneratedVisitor;
11305        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11306            type Value = stream_fragment_graph::StreamFragment;
11307
11308            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11309                formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragment")
11310            }
11311
11312            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragment, V::Error>
11313                where
11314                    V: serde::de::MapAccess<'de>,
11315            {
11316                let mut fragment_id__ = None;
11317                let mut node__ = None;
11318                let mut fragment_type_mask__ = None;
11319                let mut requires_singleton__ = None;
11320                let mut table_ids_cnt__ = None;
11321                let mut upstream_table_ids__ = None;
11322                while let Some(k) = map_.next_key()? {
11323                    match k {
11324                        GeneratedField::FragmentId => {
11325                            if fragment_id__.is_some() {
11326                                return Err(serde::de::Error::duplicate_field("fragmentId"));
11327                            }
11328                            fragment_id__ = 
11329                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11330                            ;
11331                        }
11332                        GeneratedField::Node => {
11333                            if node__.is_some() {
11334                                return Err(serde::de::Error::duplicate_field("node"));
11335                            }
11336                            node__ = map_.next_value()?;
11337                        }
11338                        GeneratedField::FragmentTypeMask => {
11339                            if fragment_type_mask__.is_some() {
11340                                return Err(serde::de::Error::duplicate_field("fragmentTypeMask"));
11341                            }
11342                            fragment_type_mask__ = 
11343                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11344                            ;
11345                        }
11346                        GeneratedField::RequiresSingleton => {
11347                            if requires_singleton__.is_some() {
11348                                return Err(serde::de::Error::duplicate_field("requiresSingleton"));
11349                            }
11350                            requires_singleton__ = Some(map_.next_value()?);
11351                        }
11352                        GeneratedField::TableIdsCnt => {
11353                            if table_ids_cnt__.is_some() {
11354                                return Err(serde::de::Error::duplicate_field("tableIdsCnt"));
11355                            }
11356                            table_ids_cnt__ = 
11357                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11358                            ;
11359                        }
11360                        GeneratedField::UpstreamTableIds => {
11361                            if upstream_table_ids__.is_some() {
11362                                return Err(serde::de::Error::duplicate_field("upstreamTableIds"));
11363                            }
11364                            upstream_table_ids__ = 
11365                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
11366                                    .into_iter().map(|x| x.0).collect())
11367                            ;
11368                        }
11369                    }
11370                }
11371                Ok(stream_fragment_graph::StreamFragment {
11372                    fragment_id: fragment_id__.unwrap_or_default(),
11373                    node: node__,
11374                    fragment_type_mask: fragment_type_mask__.unwrap_or_default(),
11375                    requires_singleton: requires_singleton__.unwrap_or_default(),
11376                    table_ids_cnt: table_ids_cnt__.unwrap_or_default(),
11377                    upstream_table_ids: upstream_table_ids__.unwrap_or_default(),
11378                })
11379            }
11380        }
11381        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragment", FIELDS, GeneratedVisitor)
11382    }
11383}
11384impl serde::Serialize for stream_fragment_graph::StreamFragmentEdge {
11385    #[allow(deprecated)]
11386    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11387    where
11388        S: serde::Serializer,
11389    {
11390        use serde::ser::SerializeStruct;
11391        let mut len = 0;
11392        if self.dispatch_strategy.is_some() {
11393            len += 1;
11394        }
11395        if self.link_id != 0 {
11396            len += 1;
11397        }
11398        if self.upstream_id != 0 {
11399            len += 1;
11400        }
11401        if self.downstream_id != 0 {
11402            len += 1;
11403        }
11404        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", len)?;
11405        if let Some(v) = self.dispatch_strategy.as_ref() {
11406            struct_ser.serialize_field("dispatchStrategy", v)?;
11407        }
11408        if self.link_id != 0 {
11409            #[allow(clippy::needless_borrow)]
11410            #[allow(clippy::needless_borrows_for_generic_args)]
11411            struct_ser.serialize_field("linkId", ToString::to_string(&self.link_id).as_str())?;
11412        }
11413        if self.upstream_id != 0 {
11414            struct_ser.serialize_field("upstreamId", &self.upstream_id)?;
11415        }
11416        if self.downstream_id != 0 {
11417            struct_ser.serialize_field("downstreamId", &self.downstream_id)?;
11418        }
11419        struct_ser.end()
11420    }
11421}
11422impl<'de> serde::Deserialize<'de> for stream_fragment_graph::StreamFragmentEdge {
11423    #[allow(deprecated)]
11424    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11425    where
11426        D: serde::Deserializer<'de>,
11427    {
11428        const FIELDS: &[&str] = &[
11429            "dispatch_strategy",
11430            "dispatchStrategy",
11431            "link_id",
11432            "linkId",
11433            "upstream_id",
11434            "upstreamId",
11435            "downstream_id",
11436            "downstreamId",
11437        ];
11438
11439        #[allow(clippy::enum_variant_names)]
11440        enum GeneratedField {
11441            DispatchStrategy,
11442            LinkId,
11443            UpstreamId,
11444            DownstreamId,
11445        }
11446        impl<'de> serde::Deserialize<'de> for GeneratedField {
11447            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11448            where
11449                D: serde::Deserializer<'de>,
11450            {
11451                struct GeneratedVisitor;
11452
11453                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11454                    type Value = GeneratedField;
11455
11456                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11457                        write!(formatter, "expected one of: {:?}", &FIELDS)
11458                    }
11459
11460                    #[allow(unused_variables)]
11461                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11462                    where
11463                        E: serde::de::Error,
11464                    {
11465                        match value {
11466                            "dispatchStrategy" | "dispatch_strategy" => Ok(GeneratedField::DispatchStrategy),
11467                            "linkId" | "link_id" => Ok(GeneratedField::LinkId),
11468                            "upstreamId" | "upstream_id" => Ok(GeneratedField::UpstreamId),
11469                            "downstreamId" | "downstream_id" => Ok(GeneratedField::DownstreamId),
11470                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11471                        }
11472                    }
11473                }
11474                deserializer.deserialize_identifier(GeneratedVisitor)
11475            }
11476        }
11477        struct GeneratedVisitor;
11478        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11479            type Value = stream_fragment_graph::StreamFragmentEdge;
11480
11481            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11482                formatter.write_str("struct stream_plan.StreamFragmentGraph.StreamFragmentEdge")
11483            }
11484
11485            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_fragment_graph::StreamFragmentEdge, V::Error>
11486                where
11487                    V: serde::de::MapAccess<'de>,
11488            {
11489                let mut dispatch_strategy__ = None;
11490                let mut link_id__ = None;
11491                let mut upstream_id__ = None;
11492                let mut downstream_id__ = None;
11493                while let Some(k) = map_.next_key()? {
11494                    match k {
11495                        GeneratedField::DispatchStrategy => {
11496                            if dispatch_strategy__.is_some() {
11497                                return Err(serde::de::Error::duplicate_field("dispatchStrategy"));
11498                            }
11499                            dispatch_strategy__ = map_.next_value()?;
11500                        }
11501                        GeneratedField::LinkId => {
11502                            if link_id__.is_some() {
11503                                return Err(serde::de::Error::duplicate_field("linkId"));
11504                            }
11505                            link_id__ = 
11506                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11507                            ;
11508                        }
11509                        GeneratedField::UpstreamId => {
11510                            if upstream_id__.is_some() {
11511                                return Err(serde::de::Error::duplicate_field("upstreamId"));
11512                            }
11513                            upstream_id__ = 
11514                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11515                            ;
11516                        }
11517                        GeneratedField::DownstreamId => {
11518                            if downstream_id__.is_some() {
11519                                return Err(serde::de::Error::duplicate_field("downstreamId"));
11520                            }
11521                            downstream_id__ = 
11522                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11523                            ;
11524                        }
11525                    }
11526                }
11527                Ok(stream_fragment_graph::StreamFragmentEdge {
11528                    dispatch_strategy: dispatch_strategy__,
11529                    link_id: link_id__.unwrap_or_default(),
11530                    upstream_id: upstream_id__.unwrap_or_default(),
11531                    downstream_id: downstream_id__.unwrap_or_default(),
11532                })
11533            }
11534        }
11535        deserializer.deserialize_struct("stream_plan.StreamFragmentGraph.StreamFragmentEdge", FIELDS, GeneratedVisitor)
11536    }
11537}
11538impl serde::Serialize for StreamFsFetch {
11539    #[allow(deprecated)]
11540    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11541    where
11542        S: serde::Serializer,
11543    {
11544        use serde::ser::SerializeStruct;
11545        let mut len = 0;
11546        if self.source_id != 0 {
11547            len += 1;
11548        }
11549        if self.state_table.is_some() {
11550            len += 1;
11551        }
11552        if self.row_id_index.is_some() {
11553            len += 1;
11554        }
11555        if !self.columns.is_empty() {
11556            len += 1;
11557        }
11558        if !self.with_properties.is_empty() {
11559            len += 1;
11560        }
11561        if self.info.is_some() {
11562            len += 1;
11563        }
11564        if !self.source_name.is_empty() {
11565            len += 1;
11566        }
11567        if self.rate_limit.is_some() {
11568            len += 1;
11569        }
11570        if !self.secret_refs.is_empty() {
11571            len += 1;
11572        }
11573        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetch", len)?;
11574        if self.source_id != 0 {
11575            struct_ser.serialize_field("sourceId", &self.source_id)?;
11576        }
11577        if let Some(v) = self.state_table.as_ref() {
11578            struct_ser.serialize_field("stateTable", v)?;
11579        }
11580        if let Some(v) = self.row_id_index.as_ref() {
11581            struct_ser.serialize_field("rowIdIndex", v)?;
11582        }
11583        if !self.columns.is_empty() {
11584            struct_ser.serialize_field("columns", &self.columns)?;
11585        }
11586        if !self.with_properties.is_empty() {
11587            struct_ser.serialize_field("withProperties", &self.with_properties)?;
11588        }
11589        if let Some(v) = self.info.as_ref() {
11590            struct_ser.serialize_field("info", v)?;
11591        }
11592        if !self.source_name.is_empty() {
11593            struct_ser.serialize_field("sourceName", &self.source_name)?;
11594        }
11595        if let Some(v) = self.rate_limit.as_ref() {
11596            struct_ser.serialize_field("rateLimit", v)?;
11597        }
11598        if !self.secret_refs.is_empty() {
11599            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
11600        }
11601        struct_ser.end()
11602    }
11603}
11604impl<'de> serde::Deserialize<'de> for StreamFsFetch {
11605    #[allow(deprecated)]
11606    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11607    where
11608        D: serde::Deserializer<'de>,
11609    {
11610        const FIELDS: &[&str] = &[
11611            "source_id",
11612            "sourceId",
11613            "state_table",
11614            "stateTable",
11615            "row_id_index",
11616            "rowIdIndex",
11617            "columns",
11618            "with_properties",
11619            "withProperties",
11620            "info",
11621            "source_name",
11622            "sourceName",
11623            "rate_limit",
11624            "rateLimit",
11625            "secret_refs",
11626            "secretRefs",
11627        ];
11628
11629        #[allow(clippy::enum_variant_names)]
11630        enum GeneratedField {
11631            SourceId,
11632            StateTable,
11633            RowIdIndex,
11634            Columns,
11635            WithProperties,
11636            Info,
11637            SourceName,
11638            RateLimit,
11639            SecretRefs,
11640        }
11641        impl<'de> serde::Deserialize<'de> for GeneratedField {
11642            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11643            where
11644                D: serde::Deserializer<'de>,
11645            {
11646                struct GeneratedVisitor;
11647
11648                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11649                    type Value = GeneratedField;
11650
11651                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11652                        write!(formatter, "expected one of: {:?}", &FIELDS)
11653                    }
11654
11655                    #[allow(unused_variables)]
11656                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11657                    where
11658                        E: serde::de::Error,
11659                    {
11660                        match value {
11661                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
11662                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
11663                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
11664                            "columns" => Ok(GeneratedField::Columns),
11665                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
11666                            "info" => Ok(GeneratedField::Info),
11667                            "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
11668                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
11669                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
11670                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11671                        }
11672                    }
11673                }
11674                deserializer.deserialize_identifier(GeneratedVisitor)
11675            }
11676        }
11677        struct GeneratedVisitor;
11678        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11679            type Value = StreamFsFetch;
11680
11681            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11682                formatter.write_str("struct stream_plan.StreamFsFetch")
11683            }
11684
11685            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetch, V::Error>
11686                where
11687                    V: serde::de::MapAccess<'de>,
11688            {
11689                let mut source_id__ = None;
11690                let mut state_table__ = None;
11691                let mut row_id_index__ = None;
11692                let mut columns__ = None;
11693                let mut with_properties__ = None;
11694                let mut info__ = None;
11695                let mut source_name__ = None;
11696                let mut rate_limit__ = None;
11697                let mut secret_refs__ = None;
11698                while let Some(k) = map_.next_key()? {
11699                    match k {
11700                        GeneratedField::SourceId => {
11701                            if source_id__.is_some() {
11702                                return Err(serde::de::Error::duplicate_field("sourceId"));
11703                            }
11704                            source_id__ = 
11705                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
11706                            ;
11707                        }
11708                        GeneratedField::StateTable => {
11709                            if state_table__.is_some() {
11710                                return Err(serde::de::Error::duplicate_field("stateTable"));
11711                            }
11712                            state_table__ = map_.next_value()?;
11713                        }
11714                        GeneratedField::RowIdIndex => {
11715                            if row_id_index__.is_some() {
11716                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
11717                            }
11718                            row_id_index__ = 
11719                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11720                            ;
11721                        }
11722                        GeneratedField::Columns => {
11723                            if columns__.is_some() {
11724                                return Err(serde::de::Error::duplicate_field("columns"));
11725                            }
11726                            columns__ = Some(map_.next_value()?);
11727                        }
11728                        GeneratedField::WithProperties => {
11729                            if with_properties__.is_some() {
11730                                return Err(serde::de::Error::duplicate_field("withProperties"));
11731                            }
11732                            with_properties__ = Some(
11733                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
11734                            );
11735                        }
11736                        GeneratedField::Info => {
11737                            if info__.is_some() {
11738                                return Err(serde::de::Error::duplicate_field("info"));
11739                            }
11740                            info__ = map_.next_value()?;
11741                        }
11742                        GeneratedField::SourceName => {
11743                            if source_name__.is_some() {
11744                                return Err(serde::de::Error::duplicate_field("sourceName"));
11745                            }
11746                            source_name__ = Some(map_.next_value()?);
11747                        }
11748                        GeneratedField::RateLimit => {
11749                            if rate_limit__.is_some() {
11750                                return Err(serde::de::Error::duplicate_field("rateLimit"));
11751                            }
11752                            rate_limit__ = 
11753                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
11754                            ;
11755                        }
11756                        GeneratedField::SecretRefs => {
11757                            if secret_refs__.is_some() {
11758                                return Err(serde::de::Error::duplicate_field("secretRefs"));
11759                            }
11760                            secret_refs__ = Some(
11761                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
11762                            );
11763                        }
11764                    }
11765                }
11766                Ok(StreamFsFetch {
11767                    source_id: source_id__.unwrap_or_default(),
11768                    state_table: state_table__,
11769                    row_id_index: row_id_index__,
11770                    columns: columns__.unwrap_or_default(),
11771                    with_properties: with_properties__.unwrap_or_default(),
11772                    info: info__,
11773                    source_name: source_name__.unwrap_or_default(),
11774                    rate_limit: rate_limit__,
11775                    secret_refs: secret_refs__.unwrap_or_default(),
11776                })
11777            }
11778        }
11779        deserializer.deserialize_struct("stream_plan.StreamFsFetch", FIELDS, GeneratedVisitor)
11780    }
11781}
11782impl serde::Serialize for StreamFsFetchNode {
11783    #[allow(deprecated)]
11784    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11785    where
11786        S: serde::Serializer,
11787    {
11788        use serde::ser::SerializeStruct;
11789        let mut len = 0;
11790        if self.node_inner.is_some() {
11791            len += 1;
11792        }
11793        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamFsFetchNode", len)?;
11794        if let Some(v) = self.node_inner.as_ref() {
11795            struct_ser.serialize_field("nodeInner", v)?;
11796        }
11797        struct_ser.end()
11798    }
11799}
11800impl<'de> serde::Deserialize<'de> for StreamFsFetchNode {
11801    #[allow(deprecated)]
11802    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11803    where
11804        D: serde::Deserializer<'de>,
11805    {
11806        const FIELDS: &[&str] = &[
11807            "node_inner",
11808            "nodeInner",
11809        ];
11810
11811        #[allow(clippy::enum_variant_names)]
11812        enum GeneratedField {
11813            NodeInner,
11814        }
11815        impl<'de> serde::Deserialize<'de> for GeneratedField {
11816            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11817            where
11818                D: serde::Deserializer<'de>,
11819            {
11820                struct GeneratedVisitor;
11821
11822                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11823                    type Value = GeneratedField;
11824
11825                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11826                        write!(formatter, "expected one of: {:?}", &FIELDS)
11827                    }
11828
11829                    #[allow(unused_variables)]
11830                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11831                    where
11832                        E: serde::de::Error,
11833                    {
11834                        match value {
11835                            "nodeInner" | "node_inner" => Ok(GeneratedField::NodeInner),
11836                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11837                        }
11838                    }
11839                }
11840                deserializer.deserialize_identifier(GeneratedVisitor)
11841            }
11842        }
11843        struct GeneratedVisitor;
11844        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11845            type Value = StreamFsFetchNode;
11846
11847            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11848                formatter.write_str("struct stream_plan.StreamFsFetchNode")
11849            }
11850
11851            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamFsFetchNode, V::Error>
11852                where
11853                    V: serde::de::MapAccess<'de>,
11854            {
11855                let mut node_inner__ = None;
11856                while let Some(k) = map_.next_key()? {
11857                    match k {
11858                        GeneratedField::NodeInner => {
11859                            if node_inner__.is_some() {
11860                                return Err(serde::de::Error::duplicate_field("nodeInner"));
11861                            }
11862                            node_inner__ = map_.next_value()?;
11863                        }
11864                    }
11865                }
11866                Ok(StreamFsFetchNode {
11867                    node_inner: node_inner__,
11868                })
11869            }
11870        }
11871        deserializer.deserialize_struct("stream_plan.StreamFsFetchNode", FIELDS, GeneratedVisitor)
11872    }
11873}
11874impl serde::Serialize for StreamMessage {
11875    #[allow(deprecated)]
11876    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
11877    where
11878        S: serde::Serializer,
11879    {
11880        use serde::ser::SerializeStruct;
11881        let mut len = 0;
11882        if self.stream_message.is_some() {
11883            len += 1;
11884        }
11885        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessage", len)?;
11886        if let Some(v) = self.stream_message.as_ref() {
11887            match v {
11888                stream_message::StreamMessage::StreamChunk(v) => {
11889                    struct_ser.serialize_field("streamChunk", v)?;
11890                }
11891                stream_message::StreamMessage::Barrier(v) => {
11892                    struct_ser.serialize_field("barrier", v)?;
11893                }
11894                stream_message::StreamMessage::Watermark(v) => {
11895                    struct_ser.serialize_field("watermark", v)?;
11896                }
11897            }
11898        }
11899        struct_ser.end()
11900    }
11901}
11902impl<'de> serde::Deserialize<'de> for StreamMessage {
11903    #[allow(deprecated)]
11904    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
11905    where
11906        D: serde::Deserializer<'de>,
11907    {
11908        const FIELDS: &[&str] = &[
11909            "stream_chunk",
11910            "streamChunk",
11911            "barrier",
11912            "watermark",
11913        ];
11914
11915        #[allow(clippy::enum_variant_names)]
11916        enum GeneratedField {
11917            StreamChunk,
11918            Barrier,
11919            Watermark,
11920        }
11921        impl<'de> serde::Deserialize<'de> for GeneratedField {
11922            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
11923            where
11924                D: serde::Deserializer<'de>,
11925            {
11926                struct GeneratedVisitor;
11927
11928                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11929                    type Value = GeneratedField;
11930
11931                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11932                        write!(formatter, "expected one of: {:?}", &FIELDS)
11933                    }
11934
11935                    #[allow(unused_variables)]
11936                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
11937                    where
11938                        E: serde::de::Error,
11939                    {
11940                        match value {
11941                            "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
11942                            "barrier" => Ok(GeneratedField::Barrier),
11943                            "watermark" => Ok(GeneratedField::Watermark),
11944                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
11945                        }
11946                    }
11947                }
11948                deserializer.deserialize_identifier(GeneratedVisitor)
11949            }
11950        }
11951        struct GeneratedVisitor;
11952        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
11953            type Value = StreamMessage;
11954
11955            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
11956                formatter.write_str("struct stream_plan.StreamMessage")
11957            }
11958
11959            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessage, V::Error>
11960                where
11961                    V: serde::de::MapAccess<'de>,
11962            {
11963                let mut stream_message__ = None;
11964                while let Some(k) = map_.next_key()? {
11965                    match k {
11966                        GeneratedField::StreamChunk => {
11967                            if stream_message__.is_some() {
11968                                return Err(serde::de::Error::duplicate_field("streamChunk"));
11969                            }
11970                            stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::StreamChunk)
11971;
11972                        }
11973                        GeneratedField::Barrier => {
11974                            if stream_message__.is_some() {
11975                                return Err(serde::de::Error::duplicate_field("barrier"));
11976                            }
11977                            stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Barrier)
11978;
11979                        }
11980                        GeneratedField::Watermark => {
11981                            if stream_message__.is_some() {
11982                                return Err(serde::de::Error::duplicate_field("watermark"));
11983                            }
11984                            stream_message__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message::StreamMessage::Watermark)
11985;
11986                        }
11987                    }
11988                }
11989                Ok(StreamMessage {
11990                    stream_message: stream_message__,
11991                })
11992            }
11993        }
11994        deserializer.deserialize_struct("stream_plan.StreamMessage", FIELDS, GeneratedVisitor)
11995    }
11996}
11997impl serde::Serialize for StreamMessageBatch {
11998    #[allow(deprecated)]
11999    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12000    where
12001        S: serde::Serializer,
12002    {
12003        use serde::ser::SerializeStruct;
12004        let mut len = 0;
12005        if self.stream_message_batch.is_some() {
12006            len += 1;
12007        }
12008        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch", len)?;
12009        if let Some(v) = self.stream_message_batch.as_ref() {
12010            match v {
12011                stream_message_batch::StreamMessageBatch::StreamChunk(v) => {
12012                    struct_ser.serialize_field("streamChunk", v)?;
12013                }
12014                stream_message_batch::StreamMessageBatch::BarrierBatch(v) => {
12015                    struct_ser.serialize_field("barrierBatch", v)?;
12016                }
12017                stream_message_batch::StreamMessageBatch::Watermark(v) => {
12018                    struct_ser.serialize_field("watermark", v)?;
12019                }
12020            }
12021        }
12022        struct_ser.end()
12023    }
12024}
12025impl<'de> serde::Deserialize<'de> for StreamMessageBatch {
12026    #[allow(deprecated)]
12027    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12028    where
12029        D: serde::Deserializer<'de>,
12030    {
12031        const FIELDS: &[&str] = &[
12032            "stream_chunk",
12033            "streamChunk",
12034            "barrier_batch",
12035            "barrierBatch",
12036            "watermark",
12037        ];
12038
12039        #[allow(clippy::enum_variant_names)]
12040        enum GeneratedField {
12041            StreamChunk,
12042            BarrierBatch,
12043            Watermark,
12044        }
12045        impl<'de> serde::Deserialize<'de> for GeneratedField {
12046            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12047            where
12048                D: serde::Deserializer<'de>,
12049            {
12050                struct GeneratedVisitor;
12051
12052                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12053                    type Value = GeneratedField;
12054
12055                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12056                        write!(formatter, "expected one of: {:?}", &FIELDS)
12057                    }
12058
12059                    #[allow(unused_variables)]
12060                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12061                    where
12062                        E: serde::de::Error,
12063                    {
12064                        match value {
12065                            "streamChunk" | "stream_chunk" => Ok(GeneratedField::StreamChunk),
12066                            "barrierBatch" | "barrier_batch" => Ok(GeneratedField::BarrierBatch),
12067                            "watermark" => Ok(GeneratedField::Watermark),
12068                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12069                        }
12070                    }
12071                }
12072                deserializer.deserialize_identifier(GeneratedVisitor)
12073            }
12074        }
12075        struct GeneratedVisitor;
12076        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12077            type Value = StreamMessageBatch;
12078
12079            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12080                formatter.write_str("struct stream_plan.StreamMessageBatch")
12081            }
12082
12083            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamMessageBatch, V::Error>
12084                where
12085                    V: serde::de::MapAccess<'de>,
12086            {
12087                let mut stream_message_batch__ = None;
12088                while let Some(k) = map_.next_key()? {
12089                    match k {
12090                        GeneratedField::StreamChunk => {
12091                            if stream_message_batch__.is_some() {
12092                                return Err(serde::de::Error::duplicate_field("streamChunk"));
12093                            }
12094                            stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::StreamChunk)
12095;
12096                        }
12097                        GeneratedField::BarrierBatch => {
12098                            if stream_message_batch__.is_some() {
12099                                return Err(serde::de::Error::duplicate_field("barrierBatch"));
12100                            }
12101                            stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::BarrierBatch)
12102;
12103                        }
12104                        GeneratedField::Watermark => {
12105                            if stream_message_batch__.is_some() {
12106                                return Err(serde::de::Error::duplicate_field("watermark"));
12107                            }
12108                            stream_message_batch__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_message_batch::StreamMessageBatch::Watermark)
12109;
12110                        }
12111                    }
12112                }
12113                Ok(StreamMessageBatch {
12114                    stream_message_batch: stream_message_batch__,
12115                })
12116            }
12117        }
12118        deserializer.deserialize_struct("stream_plan.StreamMessageBatch", FIELDS, GeneratedVisitor)
12119    }
12120}
12121impl serde::Serialize for stream_message_batch::BarrierBatch {
12122    #[allow(deprecated)]
12123    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12124    where
12125        S: serde::Serializer,
12126    {
12127        use serde::ser::SerializeStruct;
12128        let mut len = 0;
12129        if !self.barriers.is_empty() {
12130            len += 1;
12131        }
12132        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", len)?;
12133        if !self.barriers.is_empty() {
12134            struct_ser.serialize_field("barriers", &self.barriers)?;
12135        }
12136        struct_ser.end()
12137    }
12138}
12139impl<'de> serde::Deserialize<'de> for stream_message_batch::BarrierBatch {
12140    #[allow(deprecated)]
12141    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12142    where
12143        D: serde::Deserializer<'de>,
12144    {
12145        const FIELDS: &[&str] = &[
12146            "barriers",
12147        ];
12148
12149        #[allow(clippy::enum_variant_names)]
12150        enum GeneratedField {
12151            Barriers,
12152        }
12153        impl<'de> serde::Deserialize<'de> for GeneratedField {
12154            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12155            where
12156                D: serde::Deserializer<'de>,
12157            {
12158                struct GeneratedVisitor;
12159
12160                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12161                    type Value = GeneratedField;
12162
12163                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12164                        write!(formatter, "expected one of: {:?}", &FIELDS)
12165                    }
12166
12167                    #[allow(unused_variables)]
12168                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12169                    where
12170                        E: serde::de::Error,
12171                    {
12172                        match value {
12173                            "barriers" => Ok(GeneratedField::Barriers),
12174                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12175                        }
12176                    }
12177                }
12178                deserializer.deserialize_identifier(GeneratedVisitor)
12179            }
12180        }
12181        struct GeneratedVisitor;
12182        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12183            type Value = stream_message_batch::BarrierBatch;
12184
12185            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12186                formatter.write_str("struct stream_plan.StreamMessageBatch.BarrierBatch")
12187            }
12188
12189            fn visit_map<V>(self, mut map_: V) -> std::result::Result<stream_message_batch::BarrierBatch, V::Error>
12190                where
12191                    V: serde::de::MapAccess<'de>,
12192            {
12193                let mut barriers__ = None;
12194                while let Some(k) = map_.next_key()? {
12195                    match k {
12196                        GeneratedField::Barriers => {
12197                            if barriers__.is_some() {
12198                                return Err(serde::de::Error::duplicate_field("barriers"));
12199                            }
12200                            barriers__ = Some(map_.next_value()?);
12201                        }
12202                    }
12203                }
12204                Ok(stream_message_batch::BarrierBatch {
12205                    barriers: barriers__.unwrap_or_default(),
12206                })
12207            }
12208        }
12209        deserializer.deserialize_struct("stream_plan.StreamMessageBatch.BarrierBatch", FIELDS, GeneratedVisitor)
12210    }
12211}
12212impl serde::Serialize for StreamNode {
12213    #[allow(deprecated)]
12214    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
12215    where
12216        S: serde::Serializer,
12217    {
12218        use serde::ser::SerializeStruct;
12219        let mut len = 0;
12220        if self.operator_id != 0 {
12221            len += 1;
12222        }
12223        if !self.input.is_empty() {
12224            len += 1;
12225        }
12226        if !self.stream_key.is_empty() {
12227            len += 1;
12228        }
12229        if self.stream_kind != 0 {
12230            len += 1;
12231        }
12232        if !self.identity.is_empty() {
12233            len += 1;
12234        }
12235        if !self.fields.is_empty() {
12236            len += 1;
12237        }
12238        if self.node_body.is_some() {
12239            len += 1;
12240        }
12241        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamNode", len)?;
12242        if self.operator_id != 0 {
12243            #[allow(clippy::needless_borrow)]
12244            #[allow(clippy::needless_borrows_for_generic_args)]
12245            struct_ser.serialize_field("operatorId", ToString::to_string(&self.operator_id).as_str())?;
12246        }
12247        if !self.input.is_empty() {
12248            struct_ser.serialize_field("input", &self.input)?;
12249        }
12250        if !self.stream_key.is_empty() {
12251            struct_ser.serialize_field("streamKey", &self.stream_key)?;
12252        }
12253        if self.stream_kind != 0 {
12254            let v = stream_node::StreamKind::try_from(self.stream_kind)
12255                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_kind)))?;
12256            struct_ser.serialize_field("streamKind", &v)?;
12257        }
12258        if !self.identity.is_empty() {
12259            struct_ser.serialize_field("identity", &self.identity)?;
12260        }
12261        if !self.fields.is_empty() {
12262            struct_ser.serialize_field("fields", &self.fields)?;
12263        }
12264        if let Some(v) = self.node_body.as_ref() {
12265            match v {
12266                stream_node::NodeBody::Source(v) => {
12267                    struct_ser.serialize_field("source", v)?;
12268                }
12269                stream_node::NodeBody::Project(v) => {
12270                    struct_ser.serialize_field("project", v)?;
12271                }
12272                stream_node::NodeBody::Filter(v) => {
12273                    struct_ser.serialize_field("filter", v)?;
12274                }
12275                stream_node::NodeBody::Materialize(v) => {
12276                    struct_ser.serialize_field("materialize", v)?;
12277                }
12278                stream_node::NodeBody::StatelessSimpleAgg(v) => {
12279                    struct_ser.serialize_field("statelessSimpleAgg", v)?;
12280                }
12281                stream_node::NodeBody::SimpleAgg(v) => {
12282                    struct_ser.serialize_field("simpleAgg", v)?;
12283                }
12284                stream_node::NodeBody::HashAgg(v) => {
12285                    struct_ser.serialize_field("hashAgg", v)?;
12286                }
12287                stream_node::NodeBody::AppendOnlyTopN(v) => {
12288                    struct_ser.serialize_field("appendOnlyTopN", v)?;
12289                }
12290                stream_node::NodeBody::HashJoin(v) => {
12291                    struct_ser.serialize_field("hashJoin", v)?;
12292                }
12293                stream_node::NodeBody::TopN(v) => {
12294                    struct_ser.serialize_field("topN", v)?;
12295                }
12296                stream_node::NodeBody::HopWindow(v) => {
12297                    struct_ser.serialize_field("hopWindow", v)?;
12298                }
12299                stream_node::NodeBody::Merge(v) => {
12300                    struct_ser.serialize_field("merge", v)?;
12301                }
12302                stream_node::NodeBody::Exchange(v) => {
12303                    struct_ser.serialize_field("exchange", v)?;
12304                }
12305                stream_node::NodeBody::StreamScan(v) => {
12306                    struct_ser.serialize_field("streamScan", v)?;
12307                }
12308                stream_node::NodeBody::BatchPlan(v) => {
12309                    struct_ser.serialize_field("batchPlan", v)?;
12310                }
12311                stream_node::NodeBody::Lookup(v) => {
12312                    struct_ser.serialize_field("lookup", v)?;
12313                }
12314                stream_node::NodeBody::Arrange(v) => {
12315                    struct_ser.serialize_field("arrange", v)?;
12316                }
12317                stream_node::NodeBody::LookupUnion(v) => {
12318                    struct_ser.serialize_field("lookupUnion", v)?;
12319                }
12320                stream_node::NodeBody::Union(v) => {
12321                    struct_ser.serialize_field("union", v)?;
12322                }
12323                stream_node::NodeBody::DeltaIndexJoin(v) => {
12324                    struct_ser.serialize_field("deltaIndexJoin", v)?;
12325                }
12326                stream_node::NodeBody::Sink(v) => {
12327                    struct_ser.serialize_field("sink", v)?;
12328                }
12329                stream_node::NodeBody::Expand(v) => {
12330                    struct_ser.serialize_field("expand", v)?;
12331                }
12332                stream_node::NodeBody::DynamicFilter(v) => {
12333                    struct_ser.serialize_field("dynamicFilter", v)?;
12334                }
12335                stream_node::NodeBody::ProjectSet(v) => {
12336                    struct_ser.serialize_field("projectSet", v)?;
12337                }
12338                stream_node::NodeBody::GroupTopN(v) => {
12339                    struct_ser.serialize_field("groupTopN", v)?;
12340                }
12341                stream_node::NodeBody::Sort(v) => {
12342                    struct_ser.serialize_field("sort", v)?;
12343                }
12344                stream_node::NodeBody::WatermarkFilter(v) => {
12345                    struct_ser.serialize_field("watermarkFilter", v)?;
12346                }
12347                stream_node::NodeBody::Dml(v) => {
12348                    struct_ser.serialize_field("dml", v)?;
12349                }
12350                stream_node::NodeBody::RowIdGen(v) => {
12351                    struct_ser.serialize_field("rowIdGen", v)?;
12352                }
12353                stream_node::NodeBody::Now(v) => {
12354                    struct_ser.serialize_field("now", v)?;
12355                }
12356                stream_node::NodeBody::AppendOnlyGroupTopN(v) => {
12357                    struct_ser.serialize_field("appendOnlyGroupTopN", v)?;
12358                }
12359                stream_node::NodeBody::TemporalJoin(v) => {
12360                    struct_ser.serialize_field("temporalJoin", v)?;
12361                }
12362                stream_node::NodeBody::BarrierRecv(v) => {
12363                    struct_ser.serialize_field("barrierRecv", v)?;
12364                }
12365                stream_node::NodeBody::Values(v) => {
12366                    struct_ser.serialize_field("values", v)?;
12367                }
12368                stream_node::NodeBody::AppendOnlyDedup(v) => {
12369                    struct_ser.serialize_field("appendOnlyDedup", v)?;
12370                }
12371                stream_node::NodeBody::NoOp(v) => {
12372                    struct_ser.serialize_field("noOp", v)?;
12373                }
12374                stream_node::NodeBody::EowcOverWindow(v) => {
12375                    struct_ser.serialize_field("eowcOverWindow", v)?;
12376                }
12377                stream_node::NodeBody::OverWindow(v) => {
12378                    struct_ser.serialize_field("overWindow", v)?;
12379                }
12380                stream_node::NodeBody::StreamFsFetch(v) => {
12381                    struct_ser.serialize_field("streamFsFetch", v)?;
12382                }
12383                stream_node::NodeBody::StreamCdcScan(v) => {
12384                    struct_ser.serialize_field("streamCdcScan", v)?;
12385                }
12386                stream_node::NodeBody::CdcFilter(v) => {
12387                    struct_ser.serialize_field("cdcFilter", v)?;
12388                }
12389                stream_node::NodeBody::SourceBackfill(v) => {
12390                    struct_ser.serialize_field("sourceBackfill", v)?;
12391                }
12392                stream_node::NodeBody::Changelog(v) => {
12393                    struct_ser.serialize_field("changelog", v)?;
12394                }
12395                stream_node::NodeBody::LocalApproxPercentile(v) => {
12396                    struct_ser.serialize_field("localApproxPercentile", v)?;
12397                }
12398                stream_node::NodeBody::GlobalApproxPercentile(v) => {
12399                    struct_ser.serialize_field("globalApproxPercentile", v)?;
12400                }
12401                stream_node::NodeBody::RowMerge(v) => {
12402                    struct_ser.serialize_field("rowMerge", v)?;
12403                }
12404                stream_node::NodeBody::AsOfJoin(v) => {
12405                    struct_ser.serialize_field("asOfJoin", v)?;
12406                }
12407                stream_node::NodeBody::SyncLogStore(v) => {
12408                    struct_ser.serialize_field("syncLogStore", v)?;
12409                }
12410                stream_node::NodeBody::MaterializedExprs(v) => {
12411                    struct_ser.serialize_field("materializedExprs", v)?;
12412                }
12413                stream_node::NodeBody::VectorIndexWrite(v) => {
12414                    struct_ser.serialize_field("vectorIndexWrite", v)?;
12415                }
12416                stream_node::NodeBody::UpstreamSinkUnion(v) => {
12417                    struct_ser.serialize_field("upstreamSinkUnion", v)?;
12418                }
12419            }
12420        }
12421        struct_ser.end()
12422    }
12423}
12424impl<'de> serde::Deserialize<'de> for StreamNode {
12425    #[allow(deprecated)]
12426    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
12427    where
12428        D: serde::Deserializer<'de>,
12429    {
12430        const FIELDS: &[&str] = &[
12431            "operator_id",
12432            "operatorId",
12433            "input",
12434            "stream_key",
12435            "streamKey",
12436            "stream_kind",
12437            "streamKind",
12438            "identity",
12439            "fields",
12440            "source",
12441            "project",
12442            "filter",
12443            "materialize",
12444            "stateless_simple_agg",
12445            "statelessSimpleAgg",
12446            "simple_agg",
12447            "simpleAgg",
12448            "hash_agg",
12449            "hashAgg",
12450            "append_only_top_n",
12451            "appendOnlyTopN",
12452            "hash_join",
12453            "hashJoin",
12454            "top_n",
12455            "topN",
12456            "hop_window",
12457            "hopWindow",
12458            "merge",
12459            "exchange",
12460            "stream_scan",
12461            "streamScan",
12462            "batch_plan",
12463            "batchPlan",
12464            "lookup",
12465            "arrange",
12466            "lookup_union",
12467            "lookupUnion",
12468            "union",
12469            "delta_index_join",
12470            "deltaIndexJoin",
12471            "sink",
12472            "expand",
12473            "dynamic_filter",
12474            "dynamicFilter",
12475            "project_set",
12476            "projectSet",
12477            "group_top_n",
12478            "groupTopN",
12479            "sort",
12480            "watermark_filter",
12481            "watermarkFilter",
12482            "dml",
12483            "row_id_gen",
12484            "rowIdGen",
12485            "now",
12486            "append_only_group_top_n",
12487            "appendOnlyGroupTopN",
12488            "temporal_join",
12489            "temporalJoin",
12490            "barrier_recv",
12491            "barrierRecv",
12492            "values",
12493            "append_only_dedup",
12494            "appendOnlyDedup",
12495            "no_op",
12496            "noOp",
12497            "eowc_over_window",
12498            "eowcOverWindow",
12499            "over_window",
12500            "overWindow",
12501            "stream_fs_fetch",
12502            "streamFsFetch",
12503            "stream_cdc_scan",
12504            "streamCdcScan",
12505            "cdc_filter",
12506            "cdcFilter",
12507            "source_backfill",
12508            "sourceBackfill",
12509            "changelog",
12510            "local_approx_percentile",
12511            "localApproxPercentile",
12512            "global_approx_percentile",
12513            "globalApproxPercentile",
12514            "row_merge",
12515            "rowMerge",
12516            "as_of_join",
12517            "asOfJoin",
12518            "sync_log_store",
12519            "syncLogStore",
12520            "materialized_exprs",
12521            "materializedExprs",
12522            "vector_index_write",
12523            "vectorIndexWrite",
12524            "upstream_sink_union",
12525            "upstreamSinkUnion",
12526        ];
12527
12528        #[allow(clippy::enum_variant_names)]
12529        enum GeneratedField {
12530            OperatorId,
12531            Input,
12532            StreamKey,
12533            StreamKind,
12534            Identity,
12535            Fields,
12536            Source,
12537            Project,
12538            Filter,
12539            Materialize,
12540            StatelessSimpleAgg,
12541            SimpleAgg,
12542            HashAgg,
12543            AppendOnlyTopN,
12544            HashJoin,
12545            TopN,
12546            HopWindow,
12547            Merge,
12548            Exchange,
12549            StreamScan,
12550            BatchPlan,
12551            Lookup,
12552            Arrange,
12553            LookupUnion,
12554            Union,
12555            DeltaIndexJoin,
12556            Sink,
12557            Expand,
12558            DynamicFilter,
12559            ProjectSet,
12560            GroupTopN,
12561            Sort,
12562            WatermarkFilter,
12563            Dml,
12564            RowIdGen,
12565            Now,
12566            AppendOnlyGroupTopN,
12567            TemporalJoin,
12568            BarrierRecv,
12569            Values,
12570            AppendOnlyDedup,
12571            NoOp,
12572            EowcOverWindow,
12573            OverWindow,
12574            StreamFsFetch,
12575            StreamCdcScan,
12576            CdcFilter,
12577            SourceBackfill,
12578            Changelog,
12579            LocalApproxPercentile,
12580            GlobalApproxPercentile,
12581            RowMerge,
12582            AsOfJoin,
12583            SyncLogStore,
12584            MaterializedExprs,
12585            VectorIndexWrite,
12586            UpstreamSinkUnion,
12587        }
12588        impl<'de> serde::Deserialize<'de> for GeneratedField {
12589            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
12590            where
12591                D: serde::Deserializer<'de>,
12592            {
12593                struct GeneratedVisitor;
12594
12595                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12596                    type Value = GeneratedField;
12597
12598                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12599                        write!(formatter, "expected one of: {:?}", &FIELDS)
12600                    }
12601
12602                    #[allow(unused_variables)]
12603                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
12604                    where
12605                        E: serde::de::Error,
12606                    {
12607                        match value {
12608                            "operatorId" | "operator_id" => Ok(GeneratedField::OperatorId),
12609                            "input" => Ok(GeneratedField::Input),
12610                            "streamKey" | "stream_key" => Ok(GeneratedField::StreamKey),
12611                            "streamKind" | "stream_kind" => Ok(GeneratedField::StreamKind),
12612                            "identity" => Ok(GeneratedField::Identity),
12613                            "fields" => Ok(GeneratedField::Fields),
12614                            "source" => Ok(GeneratedField::Source),
12615                            "project" => Ok(GeneratedField::Project),
12616                            "filter" => Ok(GeneratedField::Filter),
12617                            "materialize" => Ok(GeneratedField::Materialize),
12618                            "statelessSimpleAgg" | "stateless_simple_agg" => Ok(GeneratedField::StatelessSimpleAgg),
12619                            "simpleAgg" | "simple_agg" => Ok(GeneratedField::SimpleAgg),
12620                            "hashAgg" | "hash_agg" => Ok(GeneratedField::HashAgg),
12621                            "appendOnlyTopN" | "append_only_top_n" => Ok(GeneratedField::AppendOnlyTopN),
12622                            "hashJoin" | "hash_join" => Ok(GeneratedField::HashJoin),
12623                            "topN" | "top_n" => Ok(GeneratedField::TopN),
12624                            "hopWindow" | "hop_window" => Ok(GeneratedField::HopWindow),
12625                            "merge" => Ok(GeneratedField::Merge),
12626                            "exchange" => Ok(GeneratedField::Exchange),
12627                            "streamScan" | "stream_scan" => Ok(GeneratedField::StreamScan),
12628                            "batchPlan" | "batch_plan" => Ok(GeneratedField::BatchPlan),
12629                            "lookup" => Ok(GeneratedField::Lookup),
12630                            "arrange" => Ok(GeneratedField::Arrange),
12631                            "lookupUnion" | "lookup_union" => Ok(GeneratedField::LookupUnion),
12632                            "union" => Ok(GeneratedField::Union),
12633                            "deltaIndexJoin" | "delta_index_join" => Ok(GeneratedField::DeltaIndexJoin),
12634                            "sink" => Ok(GeneratedField::Sink),
12635                            "expand" => Ok(GeneratedField::Expand),
12636                            "dynamicFilter" | "dynamic_filter" => Ok(GeneratedField::DynamicFilter),
12637                            "projectSet" | "project_set" => Ok(GeneratedField::ProjectSet),
12638                            "groupTopN" | "group_top_n" => Ok(GeneratedField::GroupTopN),
12639                            "sort" => Ok(GeneratedField::Sort),
12640                            "watermarkFilter" | "watermark_filter" => Ok(GeneratedField::WatermarkFilter),
12641                            "dml" => Ok(GeneratedField::Dml),
12642                            "rowIdGen" | "row_id_gen" => Ok(GeneratedField::RowIdGen),
12643                            "now" => Ok(GeneratedField::Now),
12644                            "appendOnlyGroupTopN" | "append_only_group_top_n" => Ok(GeneratedField::AppendOnlyGroupTopN),
12645                            "temporalJoin" | "temporal_join" => Ok(GeneratedField::TemporalJoin),
12646                            "barrierRecv" | "barrier_recv" => Ok(GeneratedField::BarrierRecv),
12647                            "values" => Ok(GeneratedField::Values),
12648                            "appendOnlyDedup" | "append_only_dedup" => Ok(GeneratedField::AppendOnlyDedup),
12649                            "noOp" | "no_op" => Ok(GeneratedField::NoOp),
12650                            "eowcOverWindow" | "eowc_over_window" => Ok(GeneratedField::EowcOverWindow),
12651                            "overWindow" | "over_window" => Ok(GeneratedField::OverWindow),
12652                            "streamFsFetch" | "stream_fs_fetch" => Ok(GeneratedField::StreamFsFetch),
12653                            "streamCdcScan" | "stream_cdc_scan" => Ok(GeneratedField::StreamCdcScan),
12654                            "cdcFilter" | "cdc_filter" => Ok(GeneratedField::CdcFilter),
12655                            "sourceBackfill" | "source_backfill" => Ok(GeneratedField::SourceBackfill),
12656                            "changelog" => Ok(GeneratedField::Changelog),
12657                            "localApproxPercentile" | "local_approx_percentile" => Ok(GeneratedField::LocalApproxPercentile),
12658                            "globalApproxPercentile" | "global_approx_percentile" => Ok(GeneratedField::GlobalApproxPercentile),
12659                            "rowMerge" | "row_merge" => Ok(GeneratedField::RowMerge),
12660                            "asOfJoin" | "as_of_join" => Ok(GeneratedField::AsOfJoin),
12661                            "syncLogStore" | "sync_log_store" => Ok(GeneratedField::SyncLogStore),
12662                            "materializedExprs" | "materialized_exprs" => Ok(GeneratedField::MaterializedExprs),
12663                            "vectorIndexWrite" | "vector_index_write" => Ok(GeneratedField::VectorIndexWrite),
12664                            "upstreamSinkUnion" | "upstream_sink_union" => Ok(GeneratedField::UpstreamSinkUnion),
12665                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
12666                        }
12667                    }
12668                }
12669                deserializer.deserialize_identifier(GeneratedVisitor)
12670            }
12671        }
12672        struct GeneratedVisitor;
12673        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
12674            type Value = StreamNode;
12675
12676            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
12677                formatter.write_str("struct stream_plan.StreamNode")
12678            }
12679
12680            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamNode, V::Error>
12681                where
12682                    V: serde::de::MapAccess<'de>,
12683            {
12684                let mut operator_id__ = None;
12685                let mut input__ = None;
12686                let mut stream_key__ = None;
12687                let mut stream_kind__ = None;
12688                let mut identity__ = None;
12689                let mut fields__ = None;
12690                let mut node_body__ = None;
12691                while let Some(k) = map_.next_key()? {
12692                    match k {
12693                        GeneratedField::OperatorId => {
12694                            if operator_id__.is_some() {
12695                                return Err(serde::de::Error::duplicate_field("operatorId"));
12696                            }
12697                            operator_id__ = 
12698                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
12699                            ;
12700                        }
12701                        GeneratedField::Input => {
12702                            if input__.is_some() {
12703                                return Err(serde::de::Error::duplicate_field("input"));
12704                            }
12705                            input__ = Some(map_.next_value()?);
12706                        }
12707                        GeneratedField::StreamKey => {
12708                            if stream_key__.is_some() {
12709                                return Err(serde::de::Error::duplicate_field("streamKey"));
12710                            }
12711                            stream_key__ = 
12712                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
12713                                    .into_iter().map(|x| x.0).collect())
12714                            ;
12715                        }
12716                        GeneratedField::StreamKind => {
12717                            if stream_kind__.is_some() {
12718                                return Err(serde::de::Error::duplicate_field("streamKind"));
12719                            }
12720                            stream_kind__ = Some(map_.next_value::<stream_node::StreamKind>()? as i32);
12721                        }
12722                        GeneratedField::Identity => {
12723                            if identity__.is_some() {
12724                                return Err(serde::de::Error::duplicate_field("identity"));
12725                            }
12726                            identity__ = Some(map_.next_value()?);
12727                        }
12728                        GeneratedField::Fields => {
12729                            if fields__.is_some() {
12730                                return Err(serde::de::Error::duplicate_field("fields"));
12731                            }
12732                            fields__ = Some(map_.next_value()?);
12733                        }
12734                        GeneratedField::Source => {
12735                            if node_body__.is_some() {
12736                                return Err(serde::de::Error::duplicate_field("source"));
12737                            }
12738                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Source)
12739;
12740                        }
12741                        GeneratedField::Project => {
12742                            if node_body__.is_some() {
12743                                return Err(serde::de::Error::duplicate_field("project"));
12744                            }
12745                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Project)
12746;
12747                        }
12748                        GeneratedField::Filter => {
12749                            if node_body__.is_some() {
12750                                return Err(serde::de::Error::duplicate_field("filter"));
12751                            }
12752                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Filter)
12753;
12754                        }
12755                        GeneratedField::Materialize => {
12756                            if node_body__.is_some() {
12757                                return Err(serde::de::Error::duplicate_field("materialize"));
12758                            }
12759                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Materialize)
12760;
12761                        }
12762                        GeneratedField::StatelessSimpleAgg => {
12763                            if node_body__.is_some() {
12764                                return Err(serde::de::Error::duplicate_field("statelessSimpleAgg"));
12765                            }
12766                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StatelessSimpleAgg)
12767;
12768                        }
12769                        GeneratedField::SimpleAgg => {
12770                            if node_body__.is_some() {
12771                                return Err(serde::de::Error::duplicate_field("simpleAgg"));
12772                            }
12773                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SimpleAgg)
12774;
12775                        }
12776                        GeneratedField::HashAgg => {
12777                            if node_body__.is_some() {
12778                                return Err(serde::de::Error::duplicate_field("hashAgg"));
12779                            }
12780                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashAgg)
12781;
12782                        }
12783                        GeneratedField::AppendOnlyTopN => {
12784                            if node_body__.is_some() {
12785                                return Err(serde::de::Error::duplicate_field("appendOnlyTopN"));
12786                            }
12787                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyTopN)
12788;
12789                        }
12790                        GeneratedField::HashJoin => {
12791                            if node_body__.is_some() {
12792                                return Err(serde::de::Error::duplicate_field("hashJoin"));
12793                            }
12794                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HashJoin)
12795;
12796                        }
12797                        GeneratedField::TopN => {
12798                            if node_body__.is_some() {
12799                                return Err(serde::de::Error::duplicate_field("topN"));
12800                            }
12801                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TopN)
12802;
12803                        }
12804                        GeneratedField::HopWindow => {
12805                            if node_body__.is_some() {
12806                                return Err(serde::de::Error::duplicate_field("hopWindow"));
12807                            }
12808                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::HopWindow)
12809;
12810                        }
12811                        GeneratedField::Merge => {
12812                            if node_body__.is_some() {
12813                                return Err(serde::de::Error::duplicate_field("merge"));
12814                            }
12815                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Merge)
12816;
12817                        }
12818                        GeneratedField::Exchange => {
12819                            if node_body__.is_some() {
12820                                return Err(serde::de::Error::duplicate_field("exchange"));
12821                            }
12822                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Exchange)
12823;
12824                        }
12825                        GeneratedField::StreamScan => {
12826                            if node_body__.is_some() {
12827                                return Err(serde::de::Error::duplicate_field("streamScan"));
12828                            }
12829                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamScan)
12830;
12831                        }
12832                        GeneratedField::BatchPlan => {
12833                            if node_body__.is_some() {
12834                                return Err(serde::de::Error::duplicate_field("batchPlan"));
12835                            }
12836                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BatchPlan)
12837;
12838                        }
12839                        GeneratedField::Lookup => {
12840                            if node_body__.is_some() {
12841                                return Err(serde::de::Error::duplicate_field("lookup"));
12842                            }
12843                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Lookup)
12844;
12845                        }
12846                        GeneratedField::Arrange => {
12847                            if node_body__.is_some() {
12848                                return Err(serde::de::Error::duplicate_field("arrange"));
12849                            }
12850                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Arrange)
12851;
12852                        }
12853                        GeneratedField::LookupUnion => {
12854                            if node_body__.is_some() {
12855                                return Err(serde::de::Error::duplicate_field("lookupUnion"));
12856                            }
12857                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LookupUnion)
12858;
12859                        }
12860                        GeneratedField::Union => {
12861                            if node_body__.is_some() {
12862                                return Err(serde::de::Error::duplicate_field("union"));
12863                            }
12864                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Union)
12865;
12866                        }
12867                        GeneratedField::DeltaIndexJoin => {
12868                            if node_body__.is_some() {
12869                                return Err(serde::de::Error::duplicate_field("deltaIndexJoin"));
12870                            }
12871                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DeltaIndexJoin)
12872;
12873                        }
12874                        GeneratedField::Sink => {
12875                            if node_body__.is_some() {
12876                                return Err(serde::de::Error::duplicate_field("sink"));
12877                            }
12878                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sink)
12879;
12880                        }
12881                        GeneratedField::Expand => {
12882                            if node_body__.is_some() {
12883                                return Err(serde::de::Error::duplicate_field("expand"));
12884                            }
12885                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Expand)
12886;
12887                        }
12888                        GeneratedField::DynamicFilter => {
12889                            if node_body__.is_some() {
12890                                return Err(serde::de::Error::duplicate_field("dynamicFilter"));
12891                            }
12892                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::DynamicFilter)
12893;
12894                        }
12895                        GeneratedField::ProjectSet => {
12896                            if node_body__.is_some() {
12897                                return Err(serde::de::Error::duplicate_field("projectSet"));
12898                            }
12899                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::ProjectSet)
12900;
12901                        }
12902                        GeneratedField::GroupTopN => {
12903                            if node_body__.is_some() {
12904                                return Err(serde::de::Error::duplicate_field("groupTopN"));
12905                            }
12906                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GroupTopN)
12907;
12908                        }
12909                        GeneratedField::Sort => {
12910                            if node_body__.is_some() {
12911                                return Err(serde::de::Error::duplicate_field("sort"));
12912                            }
12913                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Sort)
12914;
12915                        }
12916                        GeneratedField::WatermarkFilter => {
12917                            if node_body__.is_some() {
12918                                return Err(serde::de::Error::duplicate_field("watermarkFilter"));
12919                            }
12920                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::WatermarkFilter)
12921;
12922                        }
12923                        GeneratedField::Dml => {
12924                            if node_body__.is_some() {
12925                                return Err(serde::de::Error::duplicate_field("dml"));
12926                            }
12927                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Dml)
12928;
12929                        }
12930                        GeneratedField::RowIdGen => {
12931                            if node_body__.is_some() {
12932                                return Err(serde::de::Error::duplicate_field("rowIdGen"));
12933                            }
12934                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowIdGen)
12935;
12936                        }
12937                        GeneratedField::Now => {
12938                            if node_body__.is_some() {
12939                                return Err(serde::de::Error::duplicate_field("now"));
12940                            }
12941                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Now)
12942;
12943                        }
12944                        GeneratedField::AppendOnlyGroupTopN => {
12945                            if node_body__.is_some() {
12946                                return Err(serde::de::Error::duplicate_field("appendOnlyGroupTopN"));
12947                            }
12948                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyGroupTopN)
12949;
12950                        }
12951                        GeneratedField::TemporalJoin => {
12952                            if node_body__.is_some() {
12953                                return Err(serde::de::Error::duplicate_field("temporalJoin"));
12954                            }
12955                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::TemporalJoin)
12956;
12957                        }
12958                        GeneratedField::BarrierRecv => {
12959                            if node_body__.is_some() {
12960                                return Err(serde::de::Error::duplicate_field("barrierRecv"));
12961                            }
12962                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::BarrierRecv)
12963;
12964                        }
12965                        GeneratedField::Values => {
12966                            if node_body__.is_some() {
12967                                return Err(serde::de::Error::duplicate_field("values"));
12968                            }
12969                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Values)
12970;
12971                        }
12972                        GeneratedField::AppendOnlyDedup => {
12973                            if node_body__.is_some() {
12974                                return Err(serde::de::Error::duplicate_field("appendOnlyDedup"));
12975                            }
12976                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AppendOnlyDedup)
12977;
12978                        }
12979                        GeneratedField::NoOp => {
12980                            if node_body__.is_some() {
12981                                return Err(serde::de::Error::duplicate_field("noOp"));
12982                            }
12983                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::NoOp)
12984;
12985                        }
12986                        GeneratedField::EowcOverWindow => {
12987                            if node_body__.is_some() {
12988                                return Err(serde::de::Error::duplicate_field("eowcOverWindow"));
12989                            }
12990                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::EowcOverWindow)
12991;
12992                        }
12993                        GeneratedField::OverWindow => {
12994                            if node_body__.is_some() {
12995                                return Err(serde::de::Error::duplicate_field("overWindow"));
12996                            }
12997                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::OverWindow)
12998;
12999                        }
13000                        GeneratedField::StreamFsFetch => {
13001                            if node_body__.is_some() {
13002                                return Err(serde::de::Error::duplicate_field("streamFsFetch"));
13003                            }
13004                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamFsFetch)
13005;
13006                        }
13007                        GeneratedField::StreamCdcScan => {
13008                            if node_body__.is_some() {
13009                                return Err(serde::de::Error::duplicate_field("streamCdcScan"));
13010                            }
13011                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::StreamCdcScan)
13012;
13013                        }
13014                        GeneratedField::CdcFilter => {
13015                            if node_body__.is_some() {
13016                                return Err(serde::de::Error::duplicate_field("cdcFilter"));
13017                            }
13018                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::CdcFilter)
13019;
13020                        }
13021                        GeneratedField::SourceBackfill => {
13022                            if node_body__.is_some() {
13023                                return Err(serde::de::Error::duplicate_field("sourceBackfill"));
13024                            }
13025                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SourceBackfill)
13026;
13027                        }
13028                        GeneratedField::Changelog => {
13029                            if node_body__.is_some() {
13030                                return Err(serde::de::Error::duplicate_field("changelog"));
13031                            }
13032                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::Changelog)
13033;
13034                        }
13035                        GeneratedField::LocalApproxPercentile => {
13036                            if node_body__.is_some() {
13037                                return Err(serde::de::Error::duplicate_field("localApproxPercentile"));
13038                            }
13039                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::LocalApproxPercentile)
13040;
13041                        }
13042                        GeneratedField::GlobalApproxPercentile => {
13043                            if node_body__.is_some() {
13044                                return Err(serde::de::Error::duplicate_field("globalApproxPercentile"));
13045                            }
13046                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::GlobalApproxPercentile)
13047;
13048                        }
13049                        GeneratedField::RowMerge => {
13050                            if node_body__.is_some() {
13051                                return Err(serde::de::Error::duplicate_field("rowMerge"));
13052                            }
13053                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::RowMerge)
13054;
13055                        }
13056                        GeneratedField::AsOfJoin => {
13057                            if node_body__.is_some() {
13058                                return Err(serde::de::Error::duplicate_field("asOfJoin"));
13059                            }
13060                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::AsOfJoin)
13061;
13062                        }
13063                        GeneratedField::SyncLogStore => {
13064                            if node_body__.is_some() {
13065                                return Err(serde::de::Error::duplicate_field("syncLogStore"));
13066                            }
13067                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::SyncLogStore)
13068;
13069                        }
13070                        GeneratedField::MaterializedExprs => {
13071                            if node_body__.is_some() {
13072                                return Err(serde::de::Error::duplicate_field("materializedExprs"));
13073                            }
13074                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::MaterializedExprs)
13075;
13076                        }
13077                        GeneratedField::VectorIndexWrite => {
13078                            if node_body__.is_some() {
13079                                return Err(serde::de::Error::duplicate_field("vectorIndexWrite"));
13080                            }
13081                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::VectorIndexWrite)
13082;
13083                        }
13084                        GeneratedField::UpstreamSinkUnion => {
13085                            if node_body__.is_some() {
13086                                return Err(serde::de::Error::duplicate_field("upstreamSinkUnion"));
13087                            }
13088                            node_body__ = map_.next_value::<::std::option::Option<_>>()?.map(stream_node::NodeBody::UpstreamSinkUnion)
13089;
13090                        }
13091                    }
13092                }
13093                Ok(StreamNode {
13094                    operator_id: operator_id__.unwrap_or_default(),
13095                    input: input__.unwrap_or_default(),
13096                    stream_key: stream_key__.unwrap_or_default(),
13097                    stream_kind: stream_kind__.unwrap_or_default(),
13098                    identity: identity__.unwrap_or_default(),
13099                    fields: fields__.unwrap_or_default(),
13100                    node_body: node_body__,
13101                })
13102            }
13103        }
13104        deserializer.deserialize_struct("stream_plan.StreamNode", FIELDS, GeneratedVisitor)
13105    }
13106}
13107impl serde::Serialize for stream_node::StreamKind {
13108    #[allow(deprecated)]
13109    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13110    where
13111        S: serde::Serializer,
13112    {
13113        let variant = match self {
13114            Self::Retract => "STREAM_KIND_RETRACT",
13115            Self::AppendOnly => "STREAM_KIND_APPEND_ONLY",
13116            Self::Upsert => "STREAM_KIND_UPSERT",
13117        };
13118        serializer.serialize_str(variant)
13119    }
13120}
13121impl<'de> serde::Deserialize<'de> for stream_node::StreamKind {
13122    #[allow(deprecated)]
13123    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13124    where
13125        D: serde::Deserializer<'de>,
13126    {
13127        const FIELDS: &[&str] = &[
13128            "STREAM_KIND_RETRACT",
13129            "STREAM_KIND_APPEND_ONLY",
13130            "STREAM_KIND_UPSERT",
13131        ];
13132
13133        struct GeneratedVisitor;
13134
13135        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13136            type Value = stream_node::StreamKind;
13137
13138            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13139                write!(formatter, "expected one of: {:?}", &FIELDS)
13140            }
13141
13142            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13143            where
13144                E: serde::de::Error,
13145            {
13146                i32::try_from(v)
13147                    .ok()
13148                    .and_then(|x| x.try_into().ok())
13149                    .ok_or_else(|| {
13150                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13151                    })
13152            }
13153
13154            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13155            where
13156                E: serde::de::Error,
13157            {
13158                i32::try_from(v)
13159                    .ok()
13160                    .and_then(|x| x.try_into().ok())
13161                    .ok_or_else(|| {
13162                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13163                    })
13164            }
13165
13166            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13167            where
13168                E: serde::de::Error,
13169            {
13170                match value {
13171                    "STREAM_KIND_RETRACT" => Ok(stream_node::StreamKind::Retract),
13172                    "STREAM_KIND_APPEND_ONLY" => Ok(stream_node::StreamKind::AppendOnly),
13173                    "STREAM_KIND_UPSERT" => Ok(stream_node::StreamKind::Upsert),
13174                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13175                }
13176            }
13177        }
13178        deserializer.deserialize_any(GeneratedVisitor)
13179    }
13180}
13181impl serde::Serialize for StreamScanNode {
13182    #[allow(deprecated)]
13183    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13184    where
13185        S: serde::Serializer,
13186    {
13187        use serde::ser::SerializeStruct;
13188        let mut len = 0;
13189        if self.table_id != 0 {
13190            len += 1;
13191        }
13192        if !self.upstream_column_ids.is_empty() {
13193            len += 1;
13194        }
13195        if !self.output_indices.is_empty() {
13196            len += 1;
13197        }
13198        if self.stream_scan_type != 0 {
13199            len += 1;
13200        }
13201        if self.state_table.is_some() {
13202            len += 1;
13203        }
13204        if self.table_desc.is_some() {
13205            len += 1;
13206        }
13207        if self.rate_limit.is_some() {
13208            len += 1;
13209        }
13210        if self.snapshot_read_barrier_interval != 0 {
13211            len += 1;
13212        }
13213        if self.arrangement_table.is_some() {
13214            len += 1;
13215        }
13216        if self.snapshot_backfill_epoch.is_some() {
13217            len += 1;
13218        }
13219        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamScanNode", len)?;
13220        if self.table_id != 0 {
13221            struct_ser.serialize_field("tableId", &self.table_id)?;
13222        }
13223        if !self.upstream_column_ids.is_empty() {
13224            struct_ser.serialize_field("upstreamColumnIds", &self.upstream_column_ids)?;
13225        }
13226        if !self.output_indices.is_empty() {
13227            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
13228        }
13229        if self.stream_scan_type != 0 {
13230            let v = StreamScanType::try_from(self.stream_scan_type)
13231                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.stream_scan_type)))?;
13232            struct_ser.serialize_field("streamScanType", &v)?;
13233        }
13234        if let Some(v) = self.state_table.as_ref() {
13235            struct_ser.serialize_field("stateTable", v)?;
13236        }
13237        if let Some(v) = self.table_desc.as_ref() {
13238            struct_ser.serialize_field("tableDesc", v)?;
13239        }
13240        if let Some(v) = self.rate_limit.as_ref() {
13241            struct_ser.serialize_field("rateLimit", v)?;
13242        }
13243        if self.snapshot_read_barrier_interval != 0 {
13244            struct_ser.serialize_field("snapshotReadBarrierInterval", &self.snapshot_read_barrier_interval)?;
13245        }
13246        if let Some(v) = self.arrangement_table.as_ref() {
13247            struct_ser.serialize_field("arrangementTable", v)?;
13248        }
13249        if let Some(v) = self.snapshot_backfill_epoch.as_ref() {
13250            #[allow(clippy::needless_borrow)]
13251            #[allow(clippy::needless_borrows_for_generic_args)]
13252            struct_ser.serialize_field("snapshotBackfillEpoch", ToString::to_string(&v).as_str())?;
13253        }
13254        struct_ser.end()
13255    }
13256}
13257impl<'de> serde::Deserialize<'de> for StreamScanNode {
13258    #[allow(deprecated)]
13259    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13260    where
13261        D: serde::Deserializer<'de>,
13262    {
13263        const FIELDS: &[&str] = &[
13264            "table_id",
13265            "tableId",
13266            "upstream_column_ids",
13267            "upstreamColumnIds",
13268            "output_indices",
13269            "outputIndices",
13270            "stream_scan_type",
13271            "streamScanType",
13272            "state_table",
13273            "stateTable",
13274            "table_desc",
13275            "tableDesc",
13276            "rate_limit",
13277            "rateLimit",
13278            "snapshot_read_barrier_interval",
13279            "snapshotReadBarrierInterval",
13280            "arrangement_table",
13281            "arrangementTable",
13282            "snapshot_backfill_epoch",
13283            "snapshotBackfillEpoch",
13284        ];
13285
13286        #[allow(clippy::enum_variant_names)]
13287        enum GeneratedField {
13288            TableId,
13289            UpstreamColumnIds,
13290            OutputIndices,
13291            StreamScanType,
13292            StateTable,
13293            TableDesc,
13294            RateLimit,
13295            SnapshotReadBarrierInterval,
13296            ArrangementTable,
13297            SnapshotBackfillEpoch,
13298        }
13299        impl<'de> serde::Deserialize<'de> for GeneratedField {
13300            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13301            where
13302                D: serde::Deserializer<'de>,
13303            {
13304                struct GeneratedVisitor;
13305
13306                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13307                    type Value = GeneratedField;
13308
13309                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13310                        write!(formatter, "expected one of: {:?}", &FIELDS)
13311                    }
13312
13313                    #[allow(unused_variables)]
13314                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13315                    where
13316                        E: serde::de::Error,
13317                    {
13318                        match value {
13319                            "tableId" | "table_id" => Ok(GeneratedField::TableId),
13320                            "upstreamColumnIds" | "upstream_column_ids" => Ok(GeneratedField::UpstreamColumnIds),
13321                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
13322                            "streamScanType" | "stream_scan_type" => Ok(GeneratedField::StreamScanType),
13323                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13324                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
13325                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13326                            "snapshotReadBarrierInterval" | "snapshot_read_barrier_interval" => Ok(GeneratedField::SnapshotReadBarrierInterval),
13327                            "arrangementTable" | "arrangement_table" => Ok(GeneratedField::ArrangementTable),
13328                            "snapshotBackfillEpoch" | "snapshot_backfill_epoch" => Ok(GeneratedField::SnapshotBackfillEpoch),
13329                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13330                        }
13331                    }
13332                }
13333                deserializer.deserialize_identifier(GeneratedVisitor)
13334            }
13335        }
13336        struct GeneratedVisitor;
13337        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13338            type Value = StreamScanNode;
13339
13340            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13341                formatter.write_str("struct stream_plan.StreamScanNode")
13342            }
13343
13344            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamScanNode, V::Error>
13345                where
13346                    V: serde::de::MapAccess<'de>,
13347            {
13348                let mut table_id__ = None;
13349                let mut upstream_column_ids__ = None;
13350                let mut output_indices__ = None;
13351                let mut stream_scan_type__ = None;
13352                let mut state_table__ = None;
13353                let mut table_desc__ = None;
13354                let mut rate_limit__ = None;
13355                let mut snapshot_read_barrier_interval__ = None;
13356                let mut arrangement_table__ = None;
13357                let mut snapshot_backfill_epoch__ = None;
13358                while let Some(k) = map_.next_key()? {
13359                    match k {
13360                        GeneratedField::TableId => {
13361                            if table_id__.is_some() {
13362                                return Err(serde::de::Error::duplicate_field("tableId"));
13363                            }
13364                            table_id__ = 
13365                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13366                            ;
13367                        }
13368                        GeneratedField::UpstreamColumnIds => {
13369                            if upstream_column_ids__.is_some() {
13370                                return Err(serde::de::Error::duplicate_field("upstreamColumnIds"));
13371                            }
13372                            upstream_column_ids__ = 
13373                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13374                                    .into_iter().map(|x| x.0).collect())
13375                            ;
13376                        }
13377                        GeneratedField::OutputIndices => {
13378                            if output_indices__.is_some() {
13379                                return Err(serde::de::Error::duplicate_field("outputIndices"));
13380                            }
13381                            output_indices__ = 
13382                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
13383                                    .into_iter().map(|x| x.0).collect())
13384                            ;
13385                        }
13386                        GeneratedField::StreamScanType => {
13387                            if stream_scan_type__.is_some() {
13388                                return Err(serde::de::Error::duplicate_field("streamScanType"));
13389                            }
13390                            stream_scan_type__ = Some(map_.next_value::<StreamScanType>()? as i32);
13391                        }
13392                        GeneratedField::StateTable => {
13393                            if state_table__.is_some() {
13394                                return Err(serde::de::Error::duplicate_field("stateTable"));
13395                            }
13396                            state_table__ = map_.next_value()?;
13397                        }
13398                        GeneratedField::TableDesc => {
13399                            if table_desc__.is_some() {
13400                                return Err(serde::de::Error::duplicate_field("tableDesc"));
13401                            }
13402                            table_desc__ = map_.next_value()?;
13403                        }
13404                        GeneratedField::RateLimit => {
13405                            if rate_limit__.is_some() {
13406                                return Err(serde::de::Error::duplicate_field("rateLimit"));
13407                            }
13408                            rate_limit__ = 
13409                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13410                            ;
13411                        }
13412                        GeneratedField::SnapshotReadBarrierInterval => {
13413                            if snapshot_read_barrier_interval__.is_some() {
13414                                return Err(serde::de::Error::duplicate_field("snapshotReadBarrierInterval"));
13415                            }
13416                            snapshot_read_barrier_interval__ = 
13417                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13418                            ;
13419                        }
13420                        GeneratedField::ArrangementTable => {
13421                            if arrangement_table__.is_some() {
13422                                return Err(serde::de::Error::duplicate_field("arrangementTable"));
13423                            }
13424                            arrangement_table__ = map_.next_value()?;
13425                        }
13426                        GeneratedField::SnapshotBackfillEpoch => {
13427                            if snapshot_backfill_epoch__.is_some() {
13428                                return Err(serde::de::Error::duplicate_field("snapshotBackfillEpoch"));
13429                            }
13430                            snapshot_backfill_epoch__ = 
13431                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13432                            ;
13433                        }
13434                    }
13435                }
13436                Ok(StreamScanNode {
13437                    table_id: table_id__.unwrap_or_default(),
13438                    upstream_column_ids: upstream_column_ids__.unwrap_or_default(),
13439                    output_indices: output_indices__.unwrap_or_default(),
13440                    stream_scan_type: stream_scan_type__.unwrap_or_default(),
13441                    state_table: state_table__,
13442                    table_desc: table_desc__,
13443                    rate_limit: rate_limit__,
13444                    snapshot_read_barrier_interval: snapshot_read_barrier_interval__.unwrap_or_default(),
13445                    arrangement_table: arrangement_table__,
13446                    snapshot_backfill_epoch: snapshot_backfill_epoch__,
13447                })
13448            }
13449        }
13450        deserializer.deserialize_struct("stream_plan.StreamScanNode", FIELDS, GeneratedVisitor)
13451    }
13452}
13453impl serde::Serialize for StreamScanType {
13454    #[allow(deprecated)]
13455    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13456    where
13457        S: serde::Serializer,
13458    {
13459        let variant = match self {
13460            Self::Unspecified => "STREAM_SCAN_TYPE_UNSPECIFIED",
13461            Self::Chain => "STREAM_SCAN_TYPE_CHAIN",
13462            Self::Rearrange => "STREAM_SCAN_TYPE_REARRANGE",
13463            Self::Backfill => "STREAM_SCAN_TYPE_BACKFILL",
13464            Self::UpstreamOnly => "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
13465            Self::ArrangementBackfill => "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
13466            Self::SnapshotBackfill => "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
13467            Self::CrossDbSnapshotBackfill => "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
13468        };
13469        serializer.serialize_str(variant)
13470    }
13471}
13472impl<'de> serde::Deserialize<'de> for StreamScanType {
13473    #[allow(deprecated)]
13474    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13475    where
13476        D: serde::Deserializer<'de>,
13477    {
13478        const FIELDS: &[&str] = &[
13479            "STREAM_SCAN_TYPE_UNSPECIFIED",
13480            "STREAM_SCAN_TYPE_CHAIN",
13481            "STREAM_SCAN_TYPE_REARRANGE",
13482            "STREAM_SCAN_TYPE_BACKFILL",
13483            "STREAM_SCAN_TYPE_UPSTREAM_ONLY",
13484            "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL",
13485            "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL",
13486            "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL",
13487        ];
13488
13489        struct GeneratedVisitor;
13490
13491        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13492            type Value = StreamScanType;
13493
13494            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13495                write!(formatter, "expected one of: {:?}", &FIELDS)
13496            }
13497
13498            fn visit_i64<E>(self, v: i64) -> std::result::Result<Self::Value, E>
13499            where
13500                E: serde::de::Error,
13501            {
13502                i32::try_from(v)
13503                    .ok()
13504                    .and_then(|x| x.try_into().ok())
13505                    .ok_or_else(|| {
13506                        serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
13507                    })
13508            }
13509
13510            fn visit_u64<E>(self, v: u64) -> std::result::Result<Self::Value, E>
13511            where
13512                E: serde::de::Error,
13513            {
13514                i32::try_from(v)
13515                    .ok()
13516                    .and_then(|x| x.try_into().ok())
13517                    .ok_or_else(|| {
13518                        serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
13519                    })
13520            }
13521
13522            fn visit_str<E>(self, value: &str) -> std::result::Result<Self::Value, E>
13523            where
13524                E: serde::de::Error,
13525            {
13526                match value {
13527                    "STREAM_SCAN_TYPE_UNSPECIFIED" => Ok(StreamScanType::Unspecified),
13528                    "STREAM_SCAN_TYPE_CHAIN" => Ok(StreamScanType::Chain),
13529                    "STREAM_SCAN_TYPE_REARRANGE" => Ok(StreamScanType::Rearrange),
13530                    "STREAM_SCAN_TYPE_BACKFILL" => Ok(StreamScanType::Backfill),
13531                    "STREAM_SCAN_TYPE_UPSTREAM_ONLY" => Ok(StreamScanType::UpstreamOnly),
13532                    "STREAM_SCAN_TYPE_ARRANGEMENT_BACKFILL" => Ok(StreamScanType::ArrangementBackfill),
13533                    "STREAM_SCAN_TYPE_SNAPSHOT_BACKFILL" => Ok(StreamScanType::SnapshotBackfill),
13534                    "STREAM_SCAN_TYPE_CROSS_DB_SNAPSHOT_BACKFILL" => Ok(StreamScanType::CrossDbSnapshotBackfill),
13535                    _ => Err(serde::de::Error::unknown_variant(value, FIELDS)),
13536                }
13537            }
13538        }
13539        deserializer.deserialize_any(GeneratedVisitor)
13540    }
13541}
13542impl serde::Serialize for StreamSource {
13543    #[allow(deprecated)]
13544    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13545    where
13546        S: serde::Serializer,
13547    {
13548        use serde::ser::SerializeStruct;
13549        let mut len = 0;
13550        if self.source_id != 0 {
13551            len += 1;
13552        }
13553        if self.state_table.is_some() {
13554            len += 1;
13555        }
13556        if self.row_id_index.is_some() {
13557            len += 1;
13558        }
13559        if !self.columns.is_empty() {
13560            len += 1;
13561        }
13562        if !self.with_properties.is_empty() {
13563            len += 1;
13564        }
13565        if self.info.is_some() {
13566            len += 1;
13567        }
13568        if !self.source_name.is_empty() {
13569            len += 1;
13570        }
13571        if self.rate_limit.is_some() {
13572            len += 1;
13573        }
13574        if !self.secret_refs.is_empty() {
13575            len += 1;
13576        }
13577        let mut struct_ser = serializer.serialize_struct("stream_plan.StreamSource", len)?;
13578        if self.source_id != 0 {
13579            struct_ser.serialize_field("sourceId", &self.source_id)?;
13580        }
13581        if let Some(v) = self.state_table.as_ref() {
13582            struct_ser.serialize_field("stateTable", v)?;
13583        }
13584        if let Some(v) = self.row_id_index.as_ref() {
13585            struct_ser.serialize_field("rowIdIndex", v)?;
13586        }
13587        if !self.columns.is_empty() {
13588            struct_ser.serialize_field("columns", &self.columns)?;
13589        }
13590        if !self.with_properties.is_empty() {
13591            struct_ser.serialize_field("withProperties", &self.with_properties)?;
13592        }
13593        if let Some(v) = self.info.as_ref() {
13594            struct_ser.serialize_field("info", v)?;
13595        }
13596        if !self.source_name.is_empty() {
13597            struct_ser.serialize_field("sourceName", &self.source_name)?;
13598        }
13599        if let Some(v) = self.rate_limit.as_ref() {
13600            struct_ser.serialize_field("rateLimit", v)?;
13601        }
13602        if !self.secret_refs.is_empty() {
13603            struct_ser.serialize_field("secretRefs", &self.secret_refs)?;
13604        }
13605        struct_ser.end()
13606    }
13607}
13608impl<'de> serde::Deserialize<'de> for StreamSource {
13609    #[allow(deprecated)]
13610    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13611    where
13612        D: serde::Deserializer<'de>,
13613    {
13614        const FIELDS: &[&str] = &[
13615            "source_id",
13616            "sourceId",
13617            "state_table",
13618            "stateTable",
13619            "row_id_index",
13620            "rowIdIndex",
13621            "columns",
13622            "with_properties",
13623            "withProperties",
13624            "info",
13625            "source_name",
13626            "sourceName",
13627            "rate_limit",
13628            "rateLimit",
13629            "secret_refs",
13630            "secretRefs",
13631        ];
13632
13633        #[allow(clippy::enum_variant_names)]
13634        enum GeneratedField {
13635            SourceId,
13636            StateTable,
13637            RowIdIndex,
13638            Columns,
13639            WithProperties,
13640            Info,
13641            SourceName,
13642            RateLimit,
13643            SecretRefs,
13644        }
13645        impl<'de> serde::Deserialize<'de> for GeneratedField {
13646            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13647            where
13648                D: serde::Deserializer<'de>,
13649            {
13650                struct GeneratedVisitor;
13651
13652                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13653                    type Value = GeneratedField;
13654
13655                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13656                        write!(formatter, "expected one of: {:?}", &FIELDS)
13657                    }
13658
13659                    #[allow(unused_variables)]
13660                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13661                    where
13662                        E: serde::de::Error,
13663                    {
13664                        match value {
13665                            "sourceId" | "source_id" => Ok(GeneratedField::SourceId),
13666                            "stateTable" | "state_table" => Ok(GeneratedField::StateTable),
13667                            "rowIdIndex" | "row_id_index" => Ok(GeneratedField::RowIdIndex),
13668                            "columns" => Ok(GeneratedField::Columns),
13669                            "withProperties" | "with_properties" => Ok(GeneratedField::WithProperties),
13670                            "info" => Ok(GeneratedField::Info),
13671                            "sourceName" | "source_name" => Ok(GeneratedField::SourceName),
13672                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
13673                            "secretRefs" | "secret_refs" => Ok(GeneratedField::SecretRefs),
13674                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13675                        }
13676                    }
13677                }
13678                deserializer.deserialize_identifier(GeneratedVisitor)
13679            }
13680        }
13681        struct GeneratedVisitor;
13682        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13683            type Value = StreamSource;
13684
13685            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13686                formatter.write_str("struct stream_plan.StreamSource")
13687            }
13688
13689            fn visit_map<V>(self, mut map_: V) -> std::result::Result<StreamSource, V::Error>
13690                where
13691                    V: serde::de::MapAccess<'de>,
13692            {
13693                let mut source_id__ = None;
13694                let mut state_table__ = None;
13695                let mut row_id_index__ = None;
13696                let mut columns__ = None;
13697                let mut with_properties__ = None;
13698                let mut info__ = None;
13699                let mut source_name__ = None;
13700                let mut rate_limit__ = None;
13701                let mut secret_refs__ = None;
13702                while let Some(k) = map_.next_key()? {
13703                    match k {
13704                        GeneratedField::SourceId => {
13705                            if source_id__.is_some() {
13706                                return Err(serde::de::Error::duplicate_field("sourceId"));
13707                            }
13708                            source_id__ = 
13709                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13710                            ;
13711                        }
13712                        GeneratedField::StateTable => {
13713                            if state_table__.is_some() {
13714                                return Err(serde::de::Error::duplicate_field("stateTable"));
13715                            }
13716                            state_table__ = map_.next_value()?;
13717                        }
13718                        GeneratedField::RowIdIndex => {
13719                            if row_id_index__.is_some() {
13720                                return Err(serde::de::Error::duplicate_field("rowIdIndex"));
13721                            }
13722                            row_id_index__ = 
13723                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13724                            ;
13725                        }
13726                        GeneratedField::Columns => {
13727                            if columns__.is_some() {
13728                                return Err(serde::de::Error::duplicate_field("columns"));
13729                            }
13730                            columns__ = Some(map_.next_value()?);
13731                        }
13732                        GeneratedField::WithProperties => {
13733                            if with_properties__.is_some() {
13734                                return Err(serde::de::Error::duplicate_field("withProperties"));
13735                            }
13736                            with_properties__ = Some(
13737                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
13738                            );
13739                        }
13740                        GeneratedField::Info => {
13741                            if info__.is_some() {
13742                                return Err(serde::de::Error::duplicate_field("info"));
13743                            }
13744                            info__ = map_.next_value()?;
13745                        }
13746                        GeneratedField::SourceName => {
13747                            if source_name__.is_some() {
13748                                return Err(serde::de::Error::duplicate_field("sourceName"));
13749                            }
13750                            source_name__ = Some(map_.next_value()?);
13751                        }
13752                        GeneratedField::RateLimit => {
13753                            if rate_limit__.is_some() {
13754                                return Err(serde::de::Error::duplicate_field("rateLimit"));
13755                            }
13756                            rate_limit__ = 
13757                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
13758                            ;
13759                        }
13760                        GeneratedField::SecretRefs => {
13761                            if secret_refs__.is_some() {
13762                                return Err(serde::de::Error::duplicate_field("secretRefs"));
13763                            }
13764                            secret_refs__ = Some(
13765                                map_.next_value::<std::collections::BTreeMap<_, _>>()?
13766                            );
13767                        }
13768                    }
13769                }
13770                Ok(StreamSource {
13771                    source_id: source_id__.unwrap_or_default(),
13772                    state_table: state_table__,
13773                    row_id_index: row_id_index__,
13774                    columns: columns__.unwrap_or_default(),
13775                    with_properties: with_properties__.unwrap_or_default(),
13776                    info: info__,
13777                    source_name: source_name__.unwrap_or_default(),
13778                    rate_limit: rate_limit__,
13779                    secret_refs: secret_refs__.unwrap_or_default(),
13780                })
13781            }
13782        }
13783        deserializer.deserialize_struct("stream_plan.StreamSource", FIELDS, GeneratedVisitor)
13784    }
13785}
13786impl serde::Serialize for SubscriptionUpstreamInfo {
13787    #[allow(deprecated)]
13788    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13789    where
13790        S: serde::Serializer,
13791    {
13792        use serde::ser::SerializeStruct;
13793        let mut len = 0;
13794        if self.subscriber_id != 0 {
13795            len += 1;
13796        }
13797        if self.upstream_mv_table_id != 0 {
13798            len += 1;
13799        }
13800        let mut struct_ser = serializer.serialize_struct("stream_plan.SubscriptionUpstreamInfo", len)?;
13801        if self.subscriber_id != 0 {
13802            struct_ser.serialize_field("subscriberId", &self.subscriber_id)?;
13803        }
13804        if self.upstream_mv_table_id != 0 {
13805            struct_ser.serialize_field("upstreamMvTableId", &self.upstream_mv_table_id)?;
13806        }
13807        struct_ser.end()
13808    }
13809}
13810impl<'de> serde::Deserialize<'de> for SubscriptionUpstreamInfo {
13811    #[allow(deprecated)]
13812    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13813    where
13814        D: serde::Deserializer<'de>,
13815    {
13816        const FIELDS: &[&str] = &[
13817            "subscriber_id",
13818            "subscriberId",
13819            "upstream_mv_table_id",
13820            "upstreamMvTableId",
13821        ];
13822
13823        #[allow(clippy::enum_variant_names)]
13824        enum GeneratedField {
13825            SubscriberId,
13826            UpstreamMvTableId,
13827        }
13828        impl<'de> serde::Deserialize<'de> for GeneratedField {
13829            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13830            where
13831                D: serde::Deserializer<'de>,
13832            {
13833                struct GeneratedVisitor;
13834
13835                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13836                    type Value = GeneratedField;
13837
13838                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13839                        write!(formatter, "expected one of: {:?}", &FIELDS)
13840                    }
13841
13842                    #[allow(unused_variables)]
13843                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13844                    where
13845                        E: serde::de::Error,
13846                    {
13847                        match value {
13848                            "subscriberId" | "subscriber_id" => Ok(GeneratedField::SubscriberId),
13849                            "upstreamMvTableId" | "upstream_mv_table_id" => Ok(GeneratedField::UpstreamMvTableId),
13850                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13851                        }
13852                    }
13853                }
13854                deserializer.deserialize_identifier(GeneratedVisitor)
13855            }
13856        }
13857        struct GeneratedVisitor;
13858        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13859            type Value = SubscriptionUpstreamInfo;
13860
13861            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13862                formatter.write_str("struct stream_plan.SubscriptionUpstreamInfo")
13863            }
13864
13865            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SubscriptionUpstreamInfo, V::Error>
13866                where
13867                    V: serde::de::MapAccess<'de>,
13868            {
13869                let mut subscriber_id__ = None;
13870                let mut upstream_mv_table_id__ = None;
13871                while let Some(k) = map_.next_key()? {
13872                    match k {
13873                        GeneratedField::SubscriberId => {
13874                            if subscriber_id__.is_some() {
13875                                return Err(serde::de::Error::duplicate_field("subscriberId"));
13876                            }
13877                            subscriber_id__ = 
13878                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13879                            ;
13880                        }
13881                        GeneratedField::UpstreamMvTableId => {
13882                            if upstream_mv_table_id__.is_some() {
13883                                return Err(serde::de::Error::duplicate_field("upstreamMvTableId"));
13884                            }
13885                            upstream_mv_table_id__ = 
13886                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
13887                            ;
13888                        }
13889                    }
13890                }
13891                Ok(SubscriptionUpstreamInfo {
13892                    subscriber_id: subscriber_id__.unwrap_or_default(),
13893                    upstream_mv_table_id: upstream_mv_table_id__.unwrap_or_default(),
13894                })
13895            }
13896        }
13897        deserializer.deserialize_struct("stream_plan.SubscriptionUpstreamInfo", FIELDS, GeneratedVisitor)
13898    }
13899}
13900impl serde::Serialize for SyncLogStoreNode {
13901    #[allow(deprecated)]
13902    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
13903    where
13904        S: serde::Serializer,
13905    {
13906        use serde::ser::SerializeStruct;
13907        let mut len = 0;
13908        if self.log_store_table.is_some() {
13909            len += 1;
13910        }
13911        if self.pause_duration_ms != 0 {
13912            len += 1;
13913        }
13914        if self.buffer_size != 0 {
13915            len += 1;
13916        }
13917        if self.aligned {
13918            len += 1;
13919        }
13920        let mut struct_ser = serializer.serialize_struct("stream_plan.SyncLogStoreNode", len)?;
13921        if let Some(v) = self.log_store_table.as_ref() {
13922            struct_ser.serialize_field("logStoreTable", v)?;
13923        }
13924        if self.pause_duration_ms != 0 {
13925            struct_ser.serialize_field("pauseDurationMs", &self.pause_duration_ms)?;
13926        }
13927        if self.buffer_size != 0 {
13928            struct_ser.serialize_field("bufferSize", &self.buffer_size)?;
13929        }
13930        if self.aligned {
13931            struct_ser.serialize_field("aligned", &self.aligned)?;
13932        }
13933        struct_ser.end()
13934    }
13935}
13936impl<'de> serde::Deserialize<'de> for SyncLogStoreNode {
13937    #[allow(deprecated)]
13938    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
13939    where
13940        D: serde::Deserializer<'de>,
13941    {
13942        const FIELDS: &[&str] = &[
13943            "log_store_table",
13944            "logStoreTable",
13945            "pause_duration_ms",
13946            "pauseDurationMs",
13947            "buffer_size",
13948            "bufferSize",
13949            "aligned",
13950        ];
13951
13952        #[allow(clippy::enum_variant_names)]
13953        enum GeneratedField {
13954            LogStoreTable,
13955            PauseDurationMs,
13956            BufferSize,
13957            Aligned,
13958        }
13959        impl<'de> serde::Deserialize<'de> for GeneratedField {
13960            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
13961            where
13962                D: serde::Deserializer<'de>,
13963            {
13964                struct GeneratedVisitor;
13965
13966                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13967                    type Value = GeneratedField;
13968
13969                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13970                        write!(formatter, "expected one of: {:?}", &FIELDS)
13971                    }
13972
13973                    #[allow(unused_variables)]
13974                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
13975                    where
13976                        E: serde::de::Error,
13977                    {
13978                        match value {
13979                            "logStoreTable" | "log_store_table" => Ok(GeneratedField::LogStoreTable),
13980                            "pauseDurationMs" | "pause_duration_ms" => Ok(GeneratedField::PauseDurationMs),
13981                            "bufferSize" | "buffer_size" => Ok(GeneratedField::BufferSize),
13982                            "aligned" => Ok(GeneratedField::Aligned),
13983                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
13984                        }
13985                    }
13986                }
13987                deserializer.deserialize_identifier(GeneratedVisitor)
13988            }
13989        }
13990        struct GeneratedVisitor;
13991        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
13992            type Value = SyncLogStoreNode;
13993
13994            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13995                formatter.write_str("struct stream_plan.SyncLogStoreNode")
13996            }
13997
13998            fn visit_map<V>(self, mut map_: V) -> std::result::Result<SyncLogStoreNode, V::Error>
13999                where
14000                    V: serde::de::MapAccess<'de>,
14001            {
14002                let mut log_store_table__ = None;
14003                let mut pause_duration_ms__ = None;
14004                let mut buffer_size__ = None;
14005                let mut aligned__ = None;
14006                while let Some(k) = map_.next_key()? {
14007                    match k {
14008                        GeneratedField::LogStoreTable => {
14009                            if log_store_table__.is_some() {
14010                                return Err(serde::de::Error::duplicate_field("logStoreTable"));
14011                            }
14012                            log_store_table__ = map_.next_value()?;
14013                        }
14014                        GeneratedField::PauseDurationMs => {
14015                            if pause_duration_ms__.is_some() {
14016                                return Err(serde::de::Error::duplicate_field("pauseDurationMs"));
14017                            }
14018                            pause_duration_ms__ = 
14019                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14020                            ;
14021                        }
14022                        GeneratedField::BufferSize => {
14023                            if buffer_size__.is_some() {
14024                                return Err(serde::de::Error::duplicate_field("bufferSize"));
14025                            }
14026                            buffer_size__ = 
14027                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14028                            ;
14029                        }
14030                        GeneratedField::Aligned => {
14031                            if aligned__.is_some() {
14032                                return Err(serde::de::Error::duplicate_field("aligned"));
14033                            }
14034                            aligned__ = Some(map_.next_value()?);
14035                        }
14036                    }
14037                }
14038                Ok(SyncLogStoreNode {
14039                    log_store_table: log_store_table__,
14040                    pause_duration_ms: pause_duration_ms__.unwrap_or_default(),
14041                    buffer_size: buffer_size__.unwrap_or_default(),
14042                    aligned: aligned__.unwrap_or_default(),
14043                })
14044            }
14045        }
14046        deserializer.deserialize_struct("stream_plan.SyncLogStoreNode", FIELDS, GeneratedVisitor)
14047    }
14048}
14049impl serde::Serialize for TemporalJoinNode {
14050    #[allow(deprecated)]
14051    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14052    where
14053        S: serde::Serializer,
14054    {
14055        use serde::ser::SerializeStruct;
14056        let mut len = 0;
14057        if self.join_type != 0 {
14058            len += 1;
14059        }
14060        if !self.left_key.is_empty() {
14061            len += 1;
14062        }
14063        if !self.right_key.is_empty() {
14064            len += 1;
14065        }
14066        if !self.null_safe.is_empty() {
14067            len += 1;
14068        }
14069        if self.condition.is_some() {
14070            len += 1;
14071        }
14072        if !self.output_indices.is_empty() {
14073            len += 1;
14074        }
14075        if self.table_desc.is_some() {
14076            len += 1;
14077        }
14078        if !self.table_output_indices.is_empty() {
14079            len += 1;
14080        }
14081        if self.memo_table.is_some() {
14082            len += 1;
14083        }
14084        if self.is_nested_loop {
14085            len += 1;
14086        }
14087        let mut struct_ser = serializer.serialize_struct("stream_plan.TemporalJoinNode", len)?;
14088        if self.join_type != 0 {
14089            let v = super::plan_common::JoinType::try_from(self.join_type)
14090                .map_err(|_| serde::ser::Error::custom(format!("Invalid variant {}", self.join_type)))?;
14091            struct_ser.serialize_field("joinType", &v)?;
14092        }
14093        if !self.left_key.is_empty() {
14094            struct_ser.serialize_field("leftKey", &self.left_key)?;
14095        }
14096        if !self.right_key.is_empty() {
14097            struct_ser.serialize_field("rightKey", &self.right_key)?;
14098        }
14099        if !self.null_safe.is_empty() {
14100            struct_ser.serialize_field("nullSafe", &self.null_safe)?;
14101        }
14102        if let Some(v) = self.condition.as_ref() {
14103            struct_ser.serialize_field("condition", v)?;
14104        }
14105        if !self.output_indices.is_empty() {
14106            struct_ser.serialize_field("outputIndices", &self.output_indices)?;
14107        }
14108        if let Some(v) = self.table_desc.as_ref() {
14109            struct_ser.serialize_field("tableDesc", v)?;
14110        }
14111        if !self.table_output_indices.is_empty() {
14112            struct_ser.serialize_field("tableOutputIndices", &self.table_output_indices)?;
14113        }
14114        if let Some(v) = self.memo_table.as_ref() {
14115            struct_ser.serialize_field("memoTable", v)?;
14116        }
14117        if self.is_nested_loop {
14118            struct_ser.serialize_field("isNestedLoop", &self.is_nested_loop)?;
14119        }
14120        struct_ser.end()
14121    }
14122}
14123impl<'de> serde::Deserialize<'de> for TemporalJoinNode {
14124    #[allow(deprecated)]
14125    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14126    where
14127        D: serde::Deserializer<'de>,
14128    {
14129        const FIELDS: &[&str] = &[
14130            "join_type",
14131            "joinType",
14132            "left_key",
14133            "leftKey",
14134            "right_key",
14135            "rightKey",
14136            "null_safe",
14137            "nullSafe",
14138            "condition",
14139            "output_indices",
14140            "outputIndices",
14141            "table_desc",
14142            "tableDesc",
14143            "table_output_indices",
14144            "tableOutputIndices",
14145            "memo_table",
14146            "memoTable",
14147            "is_nested_loop",
14148            "isNestedLoop",
14149        ];
14150
14151        #[allow(clippy::enum_variant_names)]
14152        enum GeneratedField {
14153            JoinType,
14154            LeftKey,
14155            RightKey,
14156            NullSafe,
14157            Condition,
14158            OutputIndices,
14159            TableDesc,
14160            TableOutputIndices,
14161            MemoTable,
14162            IsNestedLoop,
14163        }
14164        impl<'de> serde::Deserialize<'de> for GeneratedField {
14165            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14166            where
14167                D: serde::Deserializer<'de>,
14168            {
14169                struct GeneratedVisitor;
14170
14171                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14172                    type Value = GeneratedField;
14173
14174                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14175                        write!(formatter, "expected one of: {:?}", &FIELDS)
14176                    }
14177
14178                    #[allow(unused_variables)]
14179                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14180                    where
14181                        E: serde::de::Error,
14182                    {
14183                        match value {
14184                            "joinType" | "join_type" => Ok(GeneratedField::JoinType),
14185                            "leftKey" | "left_key" => Ok(GeneratedField::LeftKey),
14186                            "rightKey" | "right_key" => Ok(GeneratedField::RightKey),
14187                            "nullSafe" | "null_safe" => Ok(GeneratedField::NullSafe),
14188                            "condition" => Ok(GeneratedField::Condition),
14189                            "outputIndices" | "output_indices" => Ok(GeneratedField::OutputIndices),
14190                            "tableDesc" | "table_desc" => Ok(GeneratedField::TableDesc),
14191                            "tableOutputIndices" | "table_output_indices" => Ok(GeneratedField::TableOutputIndices),
14192                            "memoTable" | "memo_table" => Ok(GeneratedField::MemoTable),
14193                            "isNestedLoop" | "is_nested_loop" => Ok(GeneratedField::IsNestedLoop),
14194                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14195                        }
14196                    }
14197                }
14198                deserializer.deserialize_identifier(GeneratedVisitor)
14199            }
14200        }
14201        struct GeneratedVisitor;
14202        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14203            type Value = TemporalJoinNode;
14204
14205            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14206                formatter.write_str("struct stream_plan.TemporalJoinNode")
14207            }
14208
14209            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TemporalJoinNode, V::Error>
14210                where
14211                    V: serde::de::MapAccess<'de>,
14212            {
14213                let mut join_type__ = None;
14214                let mut left_key__ = None;
14215                let mut right_key__ = None;
14216                let mut null_safe__ = None;
14217                let mut condition__ = None;
14218                let mut output_indices__ = None;
14219                let mut table_desc__ = None;
14220                let mut table_output_indices__ = None;
14221                let mut memo_table__ = None;
14222                let mut is_nested_loop__ = None;
14223                while let Some(k) = map_.next_key()? {
14224                    match k {
14225                        GeneratedField::JoinType => {
14226                            if join_type__.is_some() {
14227                                return Err(serde::de::Error::duplicate_field("joinType"));
14228                            }
14229                            join_type__ = Some(map_.next_value::<super::plan_common::JoinType>()? as i32);
14230                        }
14231                        GeneratedField::LeftKey => {
14232                            if left_key__.is_some() {
14233                                return Err(serde::de::Error::duplicate_field("leftKey"));
14234                            }
14235                            left_key__ = 
14236                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14237                                    .into_iter().map(|x| x.0).collect())
14238                            ;
14239                        }
14240                        GeneratedField::RightKey => {
14241                            if right_key__.is_some() {
14242                                return Err(serde::de::Error::duplicate_field("rightKey"));
14243                            }
14244                            right_key__ = 
14245                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14246                                    .into_iter().map(|x| x.0).collect())
14247                            ;
14248                        }
14249                        GeneratedField::NullSafe => {
14250                            if null_safe__.is_some() {
14251                                return Err(serde::de::Error::duplicate_field("nullSafe"));
14252                            }
14253                            null_safe__ = Some(map_.next_value()?);
14254                        }
14255                        GeneratedField::Condition => {
14256                            if condition__.is_some() {
14257                                return Err(serde::de::Error::duplicate_field("condition"));
14258                            }
14259                            condition__ = map_.next_value()?;
14260                        }
14261                        GeneratedField::OutputIndices => {
14262                            if output_indices__.is_some() {
14263                                return Err(serde::de::Error::duplicate_field("outputIndices"));
14264                            }
14265                            output_indices__ = 
14266                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14267                                    .into_iter().map(|x| x.0).collect())
14268                            ;
14269                        }
14270                        GeneratedField::TableDesc => {
14271                            if table_desc__.is_some() {
14272                                return Err(serde::de::Error::duplicate_field("tableDesc"));
14273                            }
14274                            table_desc__ = map_.next_value()?;
14275                        }
14276                        GeneratedField::TableOutputIndices => {
14277                            if table_output_indices__.is_some() {
14278                                return Err(serde::de::Error::duplicate_field("tableOutputIndices"));
14279                            }
14280                            table_output_indices__ = 
14281                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14282                                    .into_iter().map(|x| x.0).collect())
14283                            ;
14284                        }
14285                        GeneratedField::MemoTable => {
14286                            if memo_table__.is_some() {
14287                                return Err(serde::de::Error::duplicate_field("memoTable"));
14288                            }
14289                            memo_table__ = map_.next_value()?;
14290                        }
14291                        GeneratedField::IsNestedLoop => {
14292                            if is_nested_loop__.is_some() {
14293                                return Err(serde::de::Error::duplicate_field("isNestedLoop"));
14294                            }
14295                            is_nested_loop__ = Some(map_.next_value()?);
14296                        }
14297                    }
14298                }
14299                Ok(TemporalJoinNode {
14300                    join_type: join_type__.unwrap_or_default(),
14301                    left_key: left_key__.unwrap_or_default(),
14302                    right_key: right_key__.unwrap_or_default(),
14303                    null_safe: null_safe__.unwrap_or_default(),
14304                    condition: condition__,
14305                    output_indices: output_indices__.unwrap_or_default(),
14306                    table_desc: table_desc__,
14307                    table_output_indices: table_output_indices__.unwrap_or_default(),
14308                    memo_table: memo_table__,
14309                    is_nested_loop: is_nested_loop__.unwrap_or_default(),
14310                })
14311            }
14312        }
14313        deserializer.deserialize_struct("stream_plan.TemporalJoinNode", FIELDS, GeneratedVisitor)
14314    }
14315}
14316impl serde::Serialize for ThrottleMutation {
14317    #[allow(deprecated)]
14318    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14319    where
14320        S: serde::Serializer,
14321    {
14322        use serde::ser::SerializeStruct;
14323        let mut len = 0;
14324        if !self.actor_throttle.is_empty() {
14325            len += 1;
14326        }
14327        let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation", len)?;
14328        if !self.actor_throttle.is_empty() {
14329            struct_ser.serialize_field("actorThrottle", &self.actor_throttle)?;
14330        }
14331        struct_ser.end()
14332    }
14333}
14334impl<'de> serde::Deserialize<'de> for ThrottleMutation {
14335    #[allow(deprecated)]
14336    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14337    where
14338        D: serde::Deserializer<'de>,
14339    {
14340        const FIELDS: &[&str] = &[
14341            "actor_throttle",
14342            "actorThrottle",
14343        ];
14344
14345        #[allow(clippy::enum_variant_names)]
14346        enum GeneratedField {
14347            ActorThrottle,
14348        }
14349        impl<'de> serde::Deserialize<'de> for GeneratedField {
14350            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14351            where
14352                D: serde::Deserializer<'de>,
14353            {
14354                struct GeneratedVisitor;
14355
14356                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14357                    type Value = GeneratedField;
14358
14359                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14360                        write!(formatter, "expected one of: {:?}", &FIELDS)
14361                    }
14362
14363                    #[allow(unused_variables)]
14364                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14365                    where
14366                        E: serde::de::Error,
14367                    {
14368                        match value {
14369                            "actorThrottle" | "actor_throttle" => Ok(GeneratedField::ActorThrottle),
14370                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14371                        }
14372                    }
14373                }
14374                deserializer.deserialize_identifier(GeneratedVisitor)
14375            }
14376        }
14377        struct GeneratedVisitor;
14378        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14379            type Value = ThrottleMutation;
14380
14381            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14382                formatter.write_str("struct stream_plan.ThrottleMutation")
14383            }
14384
14385            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ThrottleMutation, V::Error>
14386                where
14387                    V: serde::de::MapAccess<'de>,
14388            {
14389                let mut actor_throttle__ = None;
14390                while let Some(k) = map_.next_key()? {
14391                    match k {
14392                        GeneratedField::ActorThrottle => {
14393                            if actor_throttle__.is_some() {
14394                                return Err(serde::de::Error::duplicate_field("actorThrottle"));
14395                            }
14396                            actor_throttle__ = Some(
14397                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14398                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
14399                            );
14400                        }
14401                    }
14402                }
14403                Ok(ThrottleMutation {
14404                    actor_throttle: actor_throttle__.unwrap_or_default(),
14405                })
14406            }
14407        }
14408        deserializer.deserialize_struct("stream_plan.ThrottleMutation", FIELDS, GeneratedVisitor)
14409    }
14410}
14411impl serde::Serialize for throttle_mutation::RateLimit {
14412    #[allow(deprecated)]
14413    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14414    where
14415        S: serde::Serializer,
14416    {
14417        use serde::ser::SerializeStruct;
14418        let mut len = 0;
14419        if self.rate_limit.is_some() {
14420            len += 1;
14421        }
14422        let mut struct_ser = serializer.serialize_struct("stream_plan.ThrottleMutation.RateLimit", len)?;
14423        if let Some(v) = self.rate_limit.as_ref() {
14424            struct_ser.serialize_field("rateLimit", v)?;
14425        }
14426        struct_ser.end()
14427    }
14428}
14429impl<'de> serde::Deserialize<'de> for throttle_mutation::RateLimit {
14430    #[allow(deprecated)]
14431    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14432    where
14433        D: serde::Deserializer<'de>,
14434    {
14435        const FIELDS: &[&str] = &[
14436            "rate_limit",
14437            "rateLimit",
14438        ];
14439
14440        #[allow(clippy::enum_variant_names)]
14441        enum GeneratedField {
14442            RateLimit,
14443        }
14444        impl<'de> serde::Deserialize<'de> for GeneratedField {
14445            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14446            where
14447                D: serde::Deserializer<'de>,
14448            {
14449                struct GeneratedVisitor;
14450
14451                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14452                    type Value = GeneratedField;
14453
14454                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14455                        write!(formatter, "expected one of: {:?}", &FIELDS)
14456                    }
14457
14458                    #[allow(unused_variables)]
14459                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14460                    where
14461                        E: serde::de::Error,
14462                    {
14463                        match value {
14464                            "rateLimit" | "rate_limit" => Ok(GeneratedField::RateLimit),
14465                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14466                        }
14467                    }
14468                }
14469                deserializer.deserialize_identifier(GeneratedVisitor)
14470            }
14471        }
14472        struct GeneratedVisitor;
14473        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14474            type Value = throttle_mutation::RateLimit;
14475
14476            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14477                formatter.write_str("struct stream_plan.ThrottleMutation.RateLimit")
14478            }
14479
14480            fn visit_map<V>(self, mut map_: V) -> std::result::Result<throttle_mutation::RateLimit, V::Error>
14481                where
14482                    V: serde::de::MapAccess<'de>,
14483            {
14484                let mut rate_limit__ = None;
14485                while let Some(k) = map_.next_key()? {
14486                    match k {
14487                        GeneratedField::RateLimit => {
14488                            if rate_limit__.is_some() {
14489                                return Err(serde::de::Error::duplicate_field("rateLimit"));
14490                            }
14491                            rate_limit__ = 
14492                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
14493                            ;
14494                        }
14495                    }
14496                }
14497                Ok(throttle_mutation::RateLimit {
14498                    rate_limit: rate_limit__,
14499                })
14500            }
14501        }
14502        deserializer.deserialize_struct("stream_plan.ThrottleMutation.RateLimit", FIELDS, GeneratedVisitor)
14503    }
14504}
14505impl serde::Serialize for TopNNode {
14506    #[allow(deprecated)]
14507    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14508    where
14509        S: serde::Serializer,
14510    {
14511        use serde::ser::SerializeStruct;
14512        let mut len = 0;
14513        if self.limit != 0 {
14514            len += 1;
14515        }
14516        if self.offset != 0 {
14517            len += 1;
14518        }
14519        if self.table.is_some() {
14520            len += 1;
14521        }
14522        if !self.order_by.is_empty() {
14523            len += 1;
14524        }
14525        if self.with_ties {
14526            len += 1;
14527        }
14528        let mut struct_ser = serializer.serialize_struct("stream_plan.TopNNode", len)?;
14529        if self.limit != 0 {
14530            #[allow(clippy::needless_borrow)]
14531            #[allow(clippy::needless_borrows_for_generic_args)]
14532            struct_ser.serialize_field("limit", ToString::to_string(&self.limit).as_str())?;
14533        }
14534        if self.offset != 0 {
14535            #[allow(clippy::needless_borrow)]
14536            #[allow(clippy::needless_borrows_for_generic_args)]
14537            struct_ser.serialize_field("offset", ToString::to_string(&self.offset).as_str())?;
14538        }
14539        if let Some(v) = self.table.as_ref() {
14540            struct_ser.serialize_field("table", v)?;
14541        }
14542        if !self.order_by.is_empty() {
14543            struct_ser.serialize_field("orderBy", &self.order_by)?;
14544        }
14545        if self.with_ties {
14546            struct_ser.serialize_field("withTies", &self.with_ties)?;
14547        }
14548        struct_ser.end()
14549    }
14550}
14551impl<'de> serde::Deserialize<'de> for TopNNode {
14552    #[allow(deprecated)]
14553    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14554    where
14555        D: serde::Deserializer<'de>,
14556    {
14557        const FIELDS: &[&str] = &[
14558            "limit",
14559            "offset",
14560            "table",
14561            "order_by",
14562            "orderBy",
14563            "with_ties",
14564            "withTies",
14565        ];
14566
14567        #[allow(clippy::enum_variant_names)]
14568        enum GeneratedField {
14569            Limit,
14570            Offset,
14571            Table,
14572            OrderBy,
14573            WithTies,
14574        }
14575        impl<'de> serde::Deserialize<'de> for GeneratedField {
14576            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14577            where
14578                D: serde::Deserializer<'de>,
14579            {
14580                struct GeneratedVisitor;
14581
14582                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14583                    type Value = GeneratedField;
14584
14585                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14586                        write!(formatter, "expected one of: {:?}", &FIELDS)
14587                    }
14588
14589                    #[allow(unused_variables)]
14590                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14591                    where
14592                        E: serde::de::Error,
14593                    {
14594                        match value {
14595                            "limit" => Ok(GeneratedField::Limit),
14596                            "offset" => Ok(GeneratedField::Offset),
14597                            "table" => Ok(GeneratedField::Table),
14598                            "orderBy" | "order_by" => Ok(GeneratedField::OrderBy),
14599                            "withTies" | "with_ties" => Ok(GeneratedField::WithTies),
14600                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14601                        }
14602                    }
14603                }
14604                deserializer.deserialize_identifier(GeneratedVisitor)
14605            }
14606        }
14607        struct GeneratedVisitor;
14608        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14609            type Value = TopNNode;
14610
14611            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14612                formatter.write_str("struct stream_plan.TopNNode")
14613            }
14614
14615            fn visit_map<V>(self, mut map_: V) -> std::result::Result<TopNNode, V::Error>
14616                where
14617                    V: serde::de::MapAccess<'de>,
14618            {
14619                let mut limit__ = None;
14620                let mut offset__ = None;
14621                let mut table__ = None;
14622                let mut order_by__ = None;
14623                let mut with_ties__ = None;
14624                while let Some(k) = map_.next_key()? {
14625                    match k {
14626                        GeneratedField::Limit => {
14627                            if limit__.is_some() {
14628                                return Err(serde::de::Error::duplicate_field("limit"));
14629                            }
14630                            limit__ = 
14631                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14632                            ;
14633                        }
14634                        GeneratedField::Offset => {
14635                            if offset__.is_some() {
14636                                return Err(serde::de::Error::duplicate_field("offset"));
14637                            }
14638                            offset__ = 
14639                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
14640                            ;
14641                        }
14642                        GeneratedField::Table => {
14643                            if table__.is_some() {
14644                                return Err(serde::de::Error::duplicate_field("table"));
14645                            }
14646                            table__ = map_.next_value()?;
14647                        }
14648                        GeneratedField::OrderBy => {
14649                            if order_by__.is_some() {
14650                                return Err(serde::de::Error::duplicate_field("orderBy"));
14651                            }
14652                            order_by__ = Some(map_.next_value()?);
14653                        }
14654                        GeneratedField::WithTies => {
14655                            if with_ties__.is_some() {
14656                                return Err(serde::de::Error::duplicate_field("withTies"));
14657                            }
14658                            with_ties__ = Some(map_.next_value()?);
14659                        }
14660                    }
14661                }
14662                Ok(TopNNode {
14663                    limit: limit__.unwrap_or_default(),
14664                    offset: offset__.unwrap_or_default(),
14665                    table: table__,
14666                    order_by: order_by__.unwrap_or_default(),
14667                    with_ties: with_ties__.unwrap_or_default(),
14668                })
14669            }
14670        }
14671        deserializer.deserialize_struct("stream_plan.TopNNode", FIELDS, GeneratedVisitor)
14672    }
14673}
14674impl serde::Serialize for UnionNode {
14675    #[allow(deprecated)]
14676    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14677    where
14678        S: serde::Serializer,
14679    {
14680        use serde::ser::SerializeStruct;
14681        let len = 0;
14682        let struct_ser = serializer.serialize_struct("stream_plan.UnionNode", len)?;
14683        struct_ser.end()
14684    }
14685}
14686impl<'de> serde::Deserialize<'de> for UnionNode {
14687    #[allow(deprecated)]
14688    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14689    where
14690        D: serde::Deserializer<'de>,
14691    {
14692        const FIELDS: &[&str] = &[
14693        ];
14694
14695        #[allow(clippy::enum_variant_names)]
14696        enum GeneratedField {
14697        }
14698        impl<'de> serde::Deserialize<'de> for GeneratedField {
14699            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14700            where
14701                D: serde::Deserializer<'de>,
14702            {
14703                struct GeneratedVisitor;
14704
14705                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14706                    type Value = GeneratedField;
14707
14708                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14709                        write!(formatter, "expected one of: {:?}", &FIELDS)
14710                    }
14711
14712                    #[allow(unused_variables)]
14713                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14714                    where
14715                        E: serde::de::Error,
14716                    {
14717                            Err(serde::de::Error::unknown_field(value, FIELDS))
14718                    }
14719                }
14720                deserializer.deserialize_identifier(GeneratedVisitor)
14721            }
14722        }
14723        struct GeneratedVisitor;
14724        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14725            type Value = UnionNode;
14726
14727            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14728                formatter.write_str("struct stream_plan.UnionNode")
14729            }
14730
14731            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UnionNode, V::Error>
14732                where
14733                    V: serde::de::MapAccess<'de>,
14734            {
14735                while map_.next_key::<GeneratedField>()?.is_some() {
14736                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
14737                }
14738                Ok(UnionNode {
14739                })
14740            }
14741        }
14742        deserializer.deserialize_struct("stream_plan.UnionNode", FIELDS, GeneratedVisitor)
14743    }
14744}
14745impl serde::Serialize for UpdateMutation {
14746    #[allow(deprecated)]
14747    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14748    where
14749        S: serde::Serializer,
14750    {
14751        use serde::ser::SerializeStruct;
14752        let mut len = 0;
14753        if !self.dispatcher_update.is_empty() {
14754            len += 1;
14755        }
14756        if !self.merge_update.is_empty() {
14757            len += 1;
14758        }
14759        if !self.actor_vnode_bitmap_update.is_empty() {
14760            len += 1;
14761        }
14762        if !self.dropped_actors.is_empty() {
14763            len += 1;
14764        }
14765        if !self.actor_splits.is_empty() {
14766            len += 1;
14767        }
14768        if !self.actor_new_dispatchers.is_empty() {
14769            len += 1;
14770        }
14771        if self.actor_cdc_table_snapshot_splits.is_some() {
14772            len += 1;
14773        }
14774        if !self.sink_add_columns.is_empty() {
14775            len += 1;
14776        }
14777        let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation", len)?;
14778        if !self.dispatcher_update.is_empty() {
14779            struct_ser.serialize_field("dispatcherUpdate", &self.dispatcher_update)?;
14780        }
14781        if !self.merge_update.is_empty() {
14782            struct_ser.serialize_field("mergeUpdate", &self.merge_update)?;
14783        }
14784        if !self.actor_vnode_bitmap_update.is_empty() {
14785            struct_ser.serialize_field("actorVnodeBitmapUpdate", &self.actor_vnode_bitmap_update)?;
14786        }
14787        if !self.dropped_actors.is_empty() {
14788            struct_ser.serialize_field("droppedActors", &self.dropped_actors)?;
14789        }
14790        if !self.actor_splits.is_empty() {
14791            struct_ser.serialize_field("actorSplits", &self.actor_splits)?;
14792        }
14793        if !self.actor_new_dispatchers.is_empty() {
14794            struct_ser.serialize_field("actorNewDispatchers", &self.actor_new_dispatchers)?;
14795        }
14796        if let Some(v) = self.actor_cdc_table_snapshot_splits.as_ref() {
14797            struct_ser.serialize_field("actorCdcTableSnapshotSplits", v)?;
14798        }
14799        if !self.sink_add_columns.is_empty() {
14800            struct_ser.serialize_field("sinkAddColumns", &self.sink_add_columns)?;
14801        }
14802        struct_ser.end()
14803    }
14804}
14805impl<'de> serde::Deserialize<'de> for UpdateMutation {
14806    #[allow(deprecated)]
14807    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
14808    where
14809        D: serde::Deserializer<'de>,
14810    {
14811        const FIELDS: &[&str] = &[
14812            "dispatcher_update",
14813            "dispatcherUpdate",
14814            "merge_update",
14815            "mergeUpdate",
14816            "actor_vnode_bitmap_update",
14817            "actorVnodeBitmapUpdate",
14818            "dropped_actors",
14819            "droppedActors",
14820            "actor_splits",
14821            "actorSplits",
14822            "actor_new_dispatchers",
14823            "actorNewDispatchers",
14824            "actor_cdc_table_snapshot_splits",
14825            "actorCdcTableSnapshotSplits",
14826            "sink_add_columns",
14827            "sinkAddColumns",
14828        ];
14829
14830        #[allow(clippy::enum_variant_names)]
14831        enum GeneratedField {
14832            DispatcherUpdate,
14833            MergeUpdate,
14834            ActorVnodeBitmapUpdate,
14835            DroppedActors,
14836            ActorSplits,
14837            ActorNewDispatchers,
14838            ActorCdcTableSnapshotSplits,
14839            SinkAddColumns,
14840        }
14841        impl<'de> serde::Deserialize<'de> for GeneratedField {
14842            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
14843            where
14844                D: serde::Deserializer<'de>,
14845            {
14846                struct GeneratedVisitor;
14847
14848                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14849                    type Value = GeneratedField;
14850
14851                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14852                        write!(formatter, "expected one of: {:?}", &FIELDS)
14853                    }
14854
14855                    #[allow(unused_variables)]
14856                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
14857                    where
14858                        E: serde::de::Error,
14859                    {
14860                        match value {
14861                            "dispatcherUpdate" | "dispatcher_update" => Ok(GeneratedField::DispatcherUpdate),
14862                            "mergeUpdate" | "merge_update" => Ok(GeneratedField::MergeUpdate),
14863                            "actorVnodeBitmapUpdate" | "actor_vnode_bitmap_update" => Ok(GeneratedField::ActorVnodeBitmapUpdate),
14864                            "droppedActors" | "dropped_actors" => Ok(GeneratedField::DroppedActors),
14865                            "actorSplits" | "actor_splits" => Ok(GeneratedField::ActorSplits),
14866                            "actorNewDispatchers" | "actor_new_dispatchers" => Ok(GeneratedField::ActorNewDispatchers),
14867                            "actorCdcTableSnapshotSplits" | "actor_cdc_table_snapshot_splits" => Ok(GeneratedField::ActorCdcTableSnapshotSplits),
14868                            "sinkAddColumns" | "sink_add_columns" => Ok(GeneratedField::SinkAddColumns),
14869                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
14870                        }
14871                    }
14872                }
14873                deserializer.deserialize_identifier(GeneratedVisitor)
14874            }
14875        }
14876        struct GeneratedVisitor;
14877        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
14878            type Value = UpdateMutation;
14879
14880            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14881                formatter.write_str("struct stream_plan.UpdateMutation")
14882            }
14883
14884            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpdateMutation, V::Error>
14885                where
14886                    V: serde::de::MapAccess<'de>,
14887            {
14888                let mut dispatcher_update__ = None;
14889                let mut merge_update__ = None;
14890                let mut actor_vnode_bitmap_update__ = None;
14891                let mut dropped_actors__ = None;
14892                let mut actor_splits__ = None;
14893                let mut actor_new_dispatchers__ = None;
14894                let mut actor_cdc_table_snapshot_splits__ = None;
14895                let mut sink_add_columns__ = None;
14896                while let Some(k) = map_.next_key()? {
14897                    match k {
14898                        GeneratedField::DispatcherUpdate => {
14899                            if dispatcher_update__.is_some() {
14900                                return Err(serde::de::Error::duplicate_field("dispatcherUpdate"));
14901                            }
14902                            dispatcher_update__ = Some(map_.next_value()?);
14903                        }
14904                        GeneratedField::MergeUpdate => {
14905                            if merge_update__.is_some() {
14906                                return Err(serde::de::Error::duplicate_field("mergeUpdate"));
14907                            }
14908                            merge_update__ = Some(map_.next_value()?);
14909                        }
14910                        GeneratedField::ActorVnodeBitmapUpdate => {
14911                            if actor_vnode_bitmap_update__.is_some() {
14912                                return Err(serde::de::Error::duplicate_field("actorVnodeBitmapUpdate"));
14913                            }
14914                            actor_vnode_bitmap_update__ = Some(
14915                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14916                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
14917                            );
14918                        }
14919                        GeneratedField::DroppedActors => {
14920                            if dropped_actors__.is_some() {
14921                                return Err(serde::de::Error::duplicate_field("droppedActors"));
14922                            }
14923                            dropped_actors__ = 
14924                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
14925                                    .into_iter().map(|x| x.0).collect())
14926                            ;
14927                        }
14928                        GeneratedField::ActorSplits => {
14929                            if actor_splits__.is_some() {
14930                                return Err(serde::de::Error::duplicate_field("actorSplits"));
14931                            }
14932                            actor_splits__ = Some(
14933                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14934                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
14935                            );
14936                        }
14937                        GeneratedField::ActorNewDispatchers => {
14938                            if actor_new_dispatchers__.is_some() {
14939                                return Err(serde::de::Error::duplicate_field("actorNewDispatchers"));
14940                            }
14941                            actor_new_dispatchers__ = Some(
14942                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14943                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
14944                            );
14945                        }
14946                        GeneratedField::ActorCdcTableSnapshotSplits => {
14947                            if actor_cdc_table_snapshot_splits__.is_some() {
14948                                return Err(serde::de::Error::duplicate_field("actorCdcTableSnapshotSplits"));
14949                            }
14950                            actor_cdc_table_snapshot_splits__ = map_.next_value()?;
14951                        }
14952                        GeneratedField::SinkAddColumns => {
14953                            if sink_add_columns__.is_some() {
14954                                return Err(serde::de::Error::duplicate_field("sinkAddColumns"));
14955                            }
14956                            sink_add_columns__ = Some(
14957                                map_.next_value::<std::collections::HashMap<::pbjson::private::NumberDeserialize<u32>, _>>()?
14958                                    .into_iter().map(|(k,v)| (k.0, v)).collect()
14959                            );
14960                        }
14961                    }
14962                }
14963                Ok(UpdateMutation {
14964                    dispatcher_update: dispatcher_update__.unwrap_or_default(),
14965                    merge_update: merge_update__.unwrap_or_default(),
14966                    actor_vnode_bitmap_update: actor_vnode_bitmap_update__.unwrap_or_default(),
14967                    dropped_actors: dropped_actors__.unwrap_or_default(),
14968                    actor_splits: actor_splits__.unwrap_or_default(),
14969                    actor_new_dispatchers: actor_new_dispatchers__.unwrap_or_default(),
14970                    actor_cdc_table_snapshot_splits: actor_cdc_table_snapshot_splits__,
14971                    sink_add_columns: sink_add_columns__.unwrap_or_default(),
14972                })
14973            }
14974        }
14975        deserializer.deserialize_struct("stream_plan.UpdateMutation", FIELDS, GeneratedVisitor)
14976    }
14977}
14978impl serde::Serialize for update_mutation::DispatcherUpdate {
14979    #[allow(deprecated)]
14980    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
14981    where
14982        S: serde::Serializer,
14983    {
14984        use serde::ser::SerializeStruct;
14985        let mut len = 0;
14986        if self.actor_id != 0 {
14987            len += 1;
14988        }
14989        if self.dispatcher_id != 0 {
14990            len += 1;
14991        }
14992        if self.hash_mapping.is_some() {
14993            len += 1;
14994        }
14995        if !self.added_downstream_actor_id.is_empty() {
14996            len += 1;
14997        }
14998        if !self.removed_downstream_actor_id.is_empty() {
14999            len += 1;
15000        }
15001        let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", len)?;
15002        if self.actor_id != 0 {
15003            struct_ser.serialize_field("actorId", &self.actor_id)?;
15004        }
15005        if self.dispatcher_id != 0 {
15006            #[allow(clippy::needless_borrow)]
15007            #[allow(clippy::needless_borrows_for_generic_args)]
15008            struct_ser.serialize_field("dispatcherId", ToString::to_string(&self.dispatcher_id).as_str())?;
15009        }
15010        if let Some(v) = self.hash_mapping.as_ref() {
15011            struct_ser.serialize_field("hashMapping", v)?;
15012        }
15013        if !self.added_downstream_actor_id.is_empty() {
15014            struct_ser.serialize_field("addedDownstreamActorId", &self.added_downstream_actor_id)?;
15015        }
15016        if !self.removed_downstream_actor_id.is_empty() {
15017            struct_ser.serialize_field("removedDownstreamActorId", &self.removed_downstream_actor_id)?;
15018        }
15019        struct_ser.end()
15020    }
15021}
15022impl<'de> serde::Deserialize<'de> for update_mutation::DispatcherUpdate {
15023    #[allow(deprecated)]
15024    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15025    where
15026        D: serde::Deserializer<'de>,
15027    {
15028        const FIELDS: &[&str] = &[
15029            "actor_id",
15030            "actorId",
15031            "dispatcher_id",
15032            "dispatcherId",
15033            "hash_mapping",
15034            "hashMapping",
15035            "added_downstream_actor_id",
15036            "addedDownstreamActorId",
15037            "removed_downstream_actor_id",
15038            "removedDownstreamActorId",
15039        ];
15040
15041        #[allow(clippy::enum_variant_names)]
15042        enum GeneratedField {
15043            ActorId,
15044            DispatcherId,
15045            HashMapping,
15046            AddedDownstreamActorId,
15047            RemovedDownstreamActorId,
15048        }
15049        impl<'de> serde::Deserialize<'de> for GeneratedField {
15050            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15051            where
15052                D: serde::Deserializer<'de>,
15053            {
15054                struct GeneratedVisitor;
15055
15056                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15057                    type Value = GeneratedField;
15058
15059                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15060                        write!(formatter, "expected one of: {:?}", &FIELDS)
15061                    }
15062
15063                    #[allow(unused_variables)]
15064                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15065                    where
15066                        E: serde::de::Error,
15067                    {
15068                        match value {
15069                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
15070                            "dispatcherId" | "dispatcher_id" => Ok(GeneratedField::DispatcherId),
15071                            "hashMapping" | "hash_mapping" => Ok(GeneratedField::HashMapping),
15072                            "addedDownstreamActorId" | "added_downstream_actor_id" => Ok(GeneratedField::AddedDownstreamActorId),
15073                            "removedDownstreamActorId" | "removed_downstream_actor_id" => Ok(GeneratedField::RemovedDownstreamActorId),
15074                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15075                        }
15076                    }
15077                }
15078                deserializer.deserialize_identifier(GeneratedVisitor)
15079            }
15080        }
15081        struct GeneratedVisitor;
15082        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15083            type Value = update_mutation::DispatcherUpdate;
15084
15085            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15086                formatter.write_str("struct stream_plan.UpdateMutation.DispatcherUpdate")
15087            }
15088
15089            fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::DispatcherUpdate, V::Error>
15090                where
15091                    V: serde::de::MapAccess<'de>,
15092            {
15093                let mut actor_id__ = None;
15094                let mut dispatcher_id__ = None;
15095                let mut hash_mapping__ = None;
15096                let mut added_downstream_actor_id__ = None;
15097                let mut removed_downstream_actor_id__ = None;
15098                while let Some(k) = map_.next_key()? {
15099                    match k {
15100                        GeneratedField::ActorId => {
15101                            if actor_id__.is_some() {
15102                                return Err(serde::de::Error::duplicate_field("actorId"));
15103                            }
15104                            actor_id__ = 
15105                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15106                            ;
15107                        }
15108                        GeneratedField::DispatcherId => {
15109                            if dispatcher_id__.is_some() {
15110                                return Err(serde::de::Error::duplicate_field("dispatcherId"));
15111                            }
15112                            dispatcher_id__ = 
15113                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15114                            ;
15115                        }
15116                        GeneratedField::HashMapping => {
15117                            if hash_mapping__.is_some() {
15118                                return Err(serde::de::Error::duplicate_field("hashMapping"));
15119                            }
15120                            hash_mapping__ = map_.next_value()?;
15121                        }
15122                        GeneratedField::AddedDownstreamActorId => {
15123                            if added_downstream_actor_id__.is_some() {
15124                                return Err(serde::de::Error::duplicate_field("addedDownstreamActorId"));
15125                            }
15126                            added_downstream_actor_id__ = 
15127                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15128                                    .into_iter().map(|x| x.0).collect())
15129                            ;
15130                        }
15131                        GeneratedField::RemovedDownstreamActorId => {
15132                            if removed_downstream_actor_id__.is_some() {
15133                                return Err(serde::de::Error::duplicate_field("removedDownstreamActorId"));
15134                            }
15135                            removed_downstream_actor_id__ = 
15136                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15137                                    .into_iter().map(|x| x.0).collect())
15138                            ;
15139                        }
15140                    }
15141                }
15142                Ok(update_mutation::DispatcherUpdate {
15143                    actor_id: actor_id__.unwrap_or_default(),
15144                    dispatcher_id: dispatcher_id__.unwrap_or_default(),
15145                    hash_mapping: hash_mapping__,
15146                    added_downstream_actor_id: added_downstream_actor_id__.unwrap_or_default(),
15147                    removed_downstream_actor_id: removed_downstream_actor_id__.unwrap_or_default(),
15148                })
15149            }
15150        }
15151        deserializer.deserialize_struct("stream_plan.UpdateMutation.DispatcherUpdate", FIELDS, GeneratedVisitor)
15152    }
15153}
15154impl serde::Serialize for update_mutation::MergeUpdate {
15155    #[allow(deprecated)]
15156    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15157    where
15158        S: serde::Serializer,
15159    {
15160        use serde::ser::SerializeStruct;
15161        let mut len = 0;
15162        if self.actor_id != 0 {
15163            len += 1;
15164        }
15165        if self.upstream_fragment_id != 0 {
15166            len += 1;
15167        }
15168        if self.new_upstream_fragment_id.is_some() {
15169            len += 1;
15170        }
15171        if !self.added_upstream_actors.is_empty() {
15172            len += 1;
15173        }
15174        if !self.removed_upstream_actor_id.is_empty() {
15175            len += 1;
15176        }
15177        let mut struct_ser = serializer.serialize_struct("stream_plan.UpdateMutation.MergeUpdate", len)?;
15178        if self.actor_id != 0 {
15179            struct_ser.serialize_field("actorId", &self.actor_id)?;
15180        }
15181        if self.upstream_fragment_id != 0 {
15182            struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
15183        }
15184        if let Some(v) = self.new_upstream_fragment_id.as_ref() {
15185            struct_ser.serialize_field("newUpstreamFragmentId", v)?;
15186        }
15187        if !self.added_upstream_actors.is_empty() {
15188            struct_ser.serialize_field("addedUpstreamActors", &self.added_upstream_actors)?;
15189        }
15190        if !self.removed_upstream_actor_id.is_empty() {
15191            struct_ser.serialize_field("removedUpstreamActorId", &self.removed_upstream_actor_id)?;
15192        }
15193        struct_ser.end()
15194    }
15195}
15196impl<'de> serde::Deserialize<'de> for update_mutation::MergeUpdate {
15197    #[allow(deprecated)]
15198    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15199    where
15200        D: serde::Deserializer<'de>,
15201    {
15202        const FIELDS: &[&str] = &[
15203            "actor_id",
15204            "actorId",
15205            "upstream_fragment_id",
15206            "upstreamFragmentId",
15207            "new_upstream_fragment_id",
15208            "newUpstreamFragmentId",
15209            "added_upstream_actors",
15210            "addedUpstreamActors",
15211            "removed_upstream_actor_id",
15212            "removedUpstreamActorId",
15213        ];
15214
15215        #[allow(clippy::enum_variant_names)]
15216        enum GeneratedField {
15217            ActorId,
15218            UpstreamFragmentId,
15219            NewUpstreamFragmentId,
15220            AddedUpstreamActors,
15221            RemovedUpstreamActorId,
15222        }
15223        impl<'de> serde::Deserialize<'de> for GeneratedField {
15224            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15225            where
15226                D: serde::Deserializer<'de>,
15227            {
15228                struct GeneratedVisitor;
15229
15230                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15231                    type Value = GeneratedField;
15232
15233                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15234                        write!(formatter, "expected one of: {:?}", &FIELDS)
15235                    }
15236
15237                    #[allow(unused_variables)]
15238                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15239                    where
15240                        E: serde::de::Error,
15241                    {
15242                        match value {
15243                            "actorId" | "actor_id" => Ok(GeneratedField::ActorId),
15244                            "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
15245                            "newUpstreamFragmentId" | "new_upstream_fragment_id" => Ok(GeneratedField::NewUpstreamFragmentId),
15246                            "addedUpstreamActors" | "added_upstream_actors" => Ok(GeneratedField::AddedUpstreamActors),
15247                            "removedUpstreamActorId" | "removed_upstream_actor_id" => Ok(GeneratedField::RemovedUpstreamActorId),
15248                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15249                        }
15250                    }
15251                }
15252                deserializer.deserialize_identifier(GeneratedVisitor)
15253            }
15254        }
15255        struct GeneratedVisitor;
15256        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15257            type Value = update_mutation::MergeUpdate;
15258
15259            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15260                formatter.write_str("struct stream_plan.UpdateMutation.MergeUpdate")
15261            }
15262
15263            fn visit_map<V>(self, mut map_: V) -> std::result::Result<update_mutation::MergeUpdate, V::Error>
15264                where
15265                    V: serde::de::MapAccess<'de>,
15266            {
15267                let mut actor_id__ = None;
15268                let mut upstream_fragment_id__ = None;
15269                let mut new_upstream_fragment_id__ = None;
15270                let mut added_upstream_actors__ = None;
15271                let mut removed_upstream_actor_id__ = None;
15272                while let Some(k) = map_.next_key()? {
15273                    match k {
15274                        GeneratedField::ActorId => {
15275                            if actor_id__.is_some() {
15276                                return Err(serde::de::Error::duplicate_field("actorId"));
15277                            }
15278                            actor_id__ = 
15279                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15280                            ;
15281                        }
15282                        GeneratedField::UpstreamFragmentId => {
15283                            if upstream_fragment_id__.is_some() {
15284                                return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
15285                            }
15286                            upstream_fragment_id__ = 
15287                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15288                            ;
15289                        }
15290                        GeneratedField::NewUpstreamFragmentId => {
15291                            if new_upstream_fragment_id__.is_some() {
15292                                return Err(serde::de::Error::duplicate_field("newUpstreamFragmentId"));
15293                            }
15294                            new_upstream_fragment_id__ = 
15295                                map_.next_value::<::std::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
15296                            ;
15297                        }
15298                        GeneratedField::AddedUpstreamActors => {
15299                            if added_upstream_actors__.is_some() {
15300                                return Err(serde::de::Error::duplicate_field("addedUpstreamActors"));
15301                            }
15302                            added_upstream_actors__ = Some(map_.next_value()?);
15303                        }
15304                        GeneratedField::RemovedUpstreamActorId => {
15305                            if removed_upstream_actor_id__.is_some() {
15306                                return Err(serde::de::Error::duplicate_field("removedUpstreamActorId"));
15307                            }
15308                            removed_upstream_actor_id__ = 
15309                                Some(map_.next_value::<Vec<::pbjson::private::NumberDeserialize<_>>>()?
15310                                    .into_iter().map(|x| x.0).collect())
15311                            ;
15312                        }
15313                    }
15314                }
15315                Ok(update_mutation::MergeUpdate {
15316                    actor_id: actor_id__.unwrap_or_default(),
15317                    upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
15318                    new_upstream_fragment_id: new_upstream_fragment_id__,
15319                    added_upstream_actors: added_upstream_actors__.unwrap_or_default(),
15320                    removed_upstream_actor_id: removed_upstream_actor_id__.unwrap_or_default(),
15321                })
15322            }
15323        }
15324        deserializer.deserialize_struct("stream_plan.UpdateMutation.MergeUpdate", FIELDS, GeneratedVisitor)
15325    }
15326}
15327impl serde::Serialize for UpstreamSinkInfo {
15328    #[allow(deprecated)]
15329    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15330    where
15331        S: serde::Serializer,
15332    {
15333        use serde::ser::SerializeStruct;
15334        let mut len = 0;
15335        if self.upstream_fragment_id != 0 {
15336            len += 1;
15337        }
15338        if !self.sink_output_schema.is_empty() {
15339            len += 1;
15340        }
15341        if !self.project_exprs.is_empty() {
15342            len += 1;
15343        }
15344        let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkInfo", len)?;
15345        if self.upstream_fragment_id != 0 {
15346            struct_ser.serialize_field("upstreamFragmentId", &self.upstream_fragment_id)?;
15347        }
15348        if !self.sink_output_schema.is_empty() {
15349            struct_ser.serialize_field("sinkOutputSchema", &self.sink_output_schema)?;
15350        }
15351        if !self.project_exprs.is_empty() {
15352            struct_ser.serialize_field("projectExprs", &self.project_exprs)?;
15353        }
15354        struct_ser.end()
15355    }
15356}
15357impl<'de> serde::Deserialize<'de> for UpstreamSinkInfo {
15358    #[allow(deprecated)]
15359    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15360    where
15361        D: serde::Deserializer<'de>,
15362    {
15363        const FIELDS: &[&str] = &[
15364            "upstream_fragment_id",
15365            "upstreamFragmentId",
15366            "sink_output_schema",
15367            "sinkOutputSchema",
15368            "project_exprs",
15369            "projectExprs",
15370        ];
15371
15372        #[allow(clippy::enum_variant_names)]
15373        enum GeneratedField {
15374            UpstreamFragmentId,
15375            SinkOutputSchema,
15376            ProjectExprs,
15377        }
15378        impl<'de> serde::Deserialize<'de> for GeneratedField {
15379            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15380            where
15381                D: serde::Deserializer<'de>,
15382            {
15383                struct GeneratedVisitor;
15384
15385                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15386                    type Value = GeneratedField;
15387
15388                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15389                        write!(formatter, "expected one of: {:?}", &FIELDS)
15390                    }
15391
15392                    #[allow(unused_variables)]
15393                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15394                    where
15395                        E: serde::de::Error,
15396                    {
15397                        match value {
15398                            "upstreamFragmentId" | "upstream_fragment_id" => Ok(GeneratedField::UpstreamFragmentId),
15399                            "sinkOutputSchema" | "sink_output_schema" => Ok(GeneratedField::SinkOutputSchema),
15400                            "projectExprs" | "project_exprs" => Ok(GeneratedField::ProjectExprs),
15401                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15402                        }
15403                    }
15404                }
15405                deserializer.deserialize_identifier(GeneratedVisitor)
15406            }
15407        }
15408        struct GeneratedVisitor;
15409        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15410            type Value = UpstreamSinkInfo;
15411
15412            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15413                formatter.write_str("struct stream_plan.UpstreamSinkInfo")
15414            }
15415
15416            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkInfo, V::Error>
15417                where
15418                    V: serde::de::MapAccess<'de>,
15419            {
15420                let mut upstream_fragment_id__ = None;
15421                let mut sink_output_schema__ = None;
15422                let mut project_exprs__ = None;
15423                while let Some(k) = map_.next_key()? {
15424                    match k {
15425                        GeneratedField::UpstreamFragmentId => {
15426                            if upstream_fragment_id__.is_some() {
15427                                return Err(serde::de::Error::duplicate_field("upstreamFragmentId"));
15428                            }
15429                            upstream_fragment_id__ = 
15430                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
15431                            ;
15432                        }
15433                        GeneratedField::SinkOutputSchema => {
15434                            if sink_output_schema__.is_some() {
15435                                return Err(serde::de::Error::duplicate_field("sinkOutputSchema"));
15436                            }
15437                            sink_output_schema__ = Some(map_.next_value()?);
15438                        }
15439                        GeneratedField::ProjectExprs => {
15440                            if project_exprs__.is_some() {
15441                                return Err(serde::de::Error::duplicate_field("projectExprs"));
15442                            }
15443                            project_exprs__ = Some(map_.next_value()?);
15444                        }
15445                    }
15446                }
15447                Ok(UpstreamSinkInfo {
15448                    upstream_fragment_id: upstream_fragment_id__.unwrap_or_default(),
15449                    sink_output_schema: sink_output_schema__.unwrap_or_default(),
15450                    project_exprs: project_exprs__.unwrap_or_default(),
15451                })
15452            }
15453        }
15454        deserializer.deserialize_struct("stream_plan.UpstreamSinkInfo", FIELDS, GeneratedVisitor)
15455    }
15456}
15457impl serde::Serialize for UpstreamSinkUnionNode {
15458    #[allow(deprecated)]
15459    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15460    where
15461        S: serde::Serializer,
15462    {
15463        use serde::ser::SerializeStruct;
15464        let mut len = 0;
15465        if !self.init_upstreams.is_empty() {
15466            len += 1;
15467        }
15468        let mut struct_ser = serializer.serialize_struct("stream_plan.UpstreamSinkUnionNode", len)?;
15469        if !self.init_upstreams.is_empty() {
15470            struct_ser.serialize_field("initUpstreams", &self.init_upstreams)?;
15471        }
15472        struct_ser.end()
15473    }
15474}
15475impl<'de> serde::Deserialize<'de> for UpstreamSinkUnionNode {
15476    #[allow(deprecated)]
15477    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15478    where
15479        D: serde::Deserializer<'de>,
15480    {
15481        const FIELDS: &[&str] = &[
15482            "init_upstreams",
15483            "initUpstreams",
15484        ];
15485
15486        #[allow(clippy::enum_variant_names)]
15487        enum GeneratedField {
15488            InitUpstreams,
15489        }
15490        impl<'de> serde::Deserialize<'de> for GeneratedField {
15491            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15492            where
15493                D: serde::Deserializer<'de>,
15494            {
15495                struct GeneratedVisitor;
15496
15497                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15498                    type Value = GeneratedField;
15499
15500                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15501                        write!(formatter, "expected one of: {:?}", &FIELDS)
15502                    }
15503
15504                    #[allow(unused_variables)]
15505                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15506                    where
15507                        E: serde::de::Error,
15508                    {
15509                        match value {
15510                            "initUpstreams" | "init_upstreams" => Ok(GeneratedField::InitUpstreams),
15511                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15512                        }
15513                    }
15514                }
15515                deserializer.deserialize_identifier(GeneratedVisitor)
15516            }
15517        }
15518        struct GeneratedVisitor;
15519        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15520            type Value = UpstreamSinkUnionNode;
15521
15522            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15523                formatter.write_str("struct stream_plan.UpstreamSinkUnionNode")
15524            }
15525
15526            fn visit_map<V>(self, mut map_: V) -> std::result::Result<UpstreamSinkUnionNode, V::Error>
15527                where
15528                    V: serde::de::MapAccess<'de>,
15529            {
15530                let mut init_upstreams__ = None;
15531                while let Some(k) = map_.next_key()? {
15532                    match k {
15533                        GeneratedField::InitUpstreams => {
15534                            if init_upstreams__.is_some() {
15535                                return Err(serde::de::Error::duplicate_field("initUpstreams"));
15536                            }
15537                            init_upstreams__ = Some(map_.next_value()?);
15538                        }
15539                    }
15540                }
15541                Ok(UpstreamSinkUnionNode {
15542                    init_upstreams: init_upstreams__.unwrap_or_default(),
15543                })
15544            }
15545        }
15546        deserializer.deserialize_struct("stream_plan.UpstreamSinkUnionNode", FIELDS, GeneratedVisitor)
15547    }
15548}
15549impl serde::Serialize for ValuesNode {
15550    #[allow(deprecated)]
15551    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15552    where
15553        S: serde::Serializer,
15554    {
15555        use serde::ser::SerializeStruct;
15556        let mut len = 0;
15557        if !self.tuples.is_empty() {
15558            len += 1;
15559        }
15560        if !self.fields.is_empty() {
15561            len += 1;
15562        }
15563        let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode", len)?;
15564        if !self.tuples.is_empty() {
15565            struct_ser.serialize_field("tuples", &self.tuples)?;
15566        }
15567        if !self.fields.is_empty() {
15568            struct_ser.serialize_field("fields", &self.fields)?;
15569        }
15570        struct_ser.end()
15571    }
15572}
15573impl<'de> serde::Deserialize<'de> for ValuesNode {
15574    #[allow(deprecated)]
15575    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15576    where
15577        D: serde::Deserializer<'de>,
15578    {
15579        const FIELDS: &[&str] = &[
15580            "tuples",
15581            "fields",
15582        ];
15583
15584        #[allow(clippy::enum_variant_names)]
15585        enum GeneratedField {
15586            Tuples,
15587            Fields,
15588        }
15589        impl<'de> serde::Deserialize<'de> for GeneratedField {
15590            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15591            where
15592                D: serde::Deserializer<'de>,
15593            {
15594                struct GeneratedVisitor;
15595
15596                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15597                    type Value = GeneratedField;
15598
15599                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15600                        write!(formatter, "expected one of: {:?}", &FIELDS)
15601                    }
15602
15603                    #[allow(unused_variables)]
15604                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15605                    where
15606                        E: serde::de::Error,
15607                    {
15608                        match value {
15609                            "tuples" => Ok(GeneratedField::Tuples),
15610                            "fields" => Ok(GeneratedField::Fields),
15611                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15612                        }
15613                    }
15614                }
15615                deserializer.deserialize_identifier(GeneratedVisitor)
15616            }
15617        }
15618        struct GeneratedVisitor;
15619        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15620            type Value = ValuesNode;
15621
15622            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15623                formatter.write_str("struct stream_plan.ValuesNode")
15624            }
15625
15626            fn visit_map<V>(self, mut map_: V) -> std::result::Result<ValuesNode, V::Error>
15627                where
15628                    V: serde::de::MapAccess<'de>,
15629            {
15630                let mut tuples__ = None;
15631                let mut fields__ = None;
15632                while let Some(k) = map_.next_key()? {
15633                    match k {
15634                        GeneratedField::Tuples => {
15635                            if tuples__.is_some() {
15636                                return Err(serde::de::Error::duplicate_field("tuples"));
15637                            }
15638                            tuples__ = Some(map_.next_value()?);
15639                        }
15640                        GeneratedField::Fields => {
15641                            if fields__.is_some() {
15642                                return Err(serde::de::Error::duplicate_field("fields"));
15643                            }
15644                            fields__ = Some(map_.next_value()?);
15645                        }
15646                    }
15647                }
15648                Ok(ValuesNode {
15649                    tuples: tuples__.unwrap_or_default(),
15650                    fields: fields__.unwrap_or_default(),
15651                })
15652            }
15653        }
15654        deserializer.deserialize_struct("stream_plan.ValuesNode", FIELDS, GeneratedVisitor)
15655    }
15656}
15657impl serde::Serialize for values_node::ExprTuple {
15658    #[allow(deprecated)]
15659    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15660    where
15661        S: serde::Serializer,
15662    {
15663        use serde::ser::SerializeStruct;
15664        let mut len = 0;
15665        if !self.cells.is_empty() {
15666            len += 1;
15667        }
15668        let mut struct_ser = serializer.serialize_struct("stream_plan.ValuesNode.ExprTuple", len)?;
15669        if !self.cells.is_empty() {
15670            struct_ser.serialize_field("cells", &self.cells)?;
15671        }
15672        struct_ser.end()
15673    }
15674}
15675impl<'de> serde::Deserialize<'de> for values_node::ExprTuple {
15676    #[allow(deprecated)]
15677    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15678    where
15679        D: serde::Deserializer<'de>,
15680    {
15681        const FIELDS: &[&str] = &[
15682            "cells",
15683        ];
15684
15685        #[allow(clippy::enum_variant_names)]
15686        enum GeneratedField {
15687            Cells,
15688        }
15689        impl<'de> serde::Deserialize<'de> for GeneratedField {
15690            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15691            where
15692                D: serde::Deserializer<'de>,
15693            {
15694                struct GeneratedVisitor;
15695
15696                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15697                    type Value = GeneratedField;
15698
15699                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15700                        write!(formatter, "expected one of: {:?}", &FIELDS)
15701                    }
15702
15703                    #[allow(unused_variables)]
15704                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15705                    where
15706                        E: serde::de::Error,
15707                    {
15708                        match value {
15709                            "cells" => Ok(GeneratedField::Cells),
15710                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15711                        }
15712                    }
15713                }
15714                deserializer.deserialize_identifier(GeneratedVisitor)
15715            }
15716        }
15717        struct GeneratedVisitor;
15718        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15719            type Value = values_node::ExprTuple;
15720
15721            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15722                formatter.write_str("struct stream_plan.ValuesNode.ExprTuple")
15723            }
15724
15725            fn visit_map<V>(self, mut map_: V) -> std::result::Result<values_node::ExprTuple, V::Error>
15726                where
15727                    V: serde::de::MapAccess<'de>,
15728            {
15729                let mut cells__ = None;
15730                while let Some(k) = map_.next_key()? {
15731                    match k {
15732                        GeneratedField::Cells => {
15733                            if cells__.is_some() {
15734                                return Err(serde::de::Error::duplicate_field("cells"));
15735                            }
15736                            cells__ = Some(map_.next_value()?);
15737                        }
15738                    }
15739                }
15740                Ok(values_node::ExprTuple {
15741                    cells: cells__.unwrap_or_default(),
15742                })
15743            }
15744        }
15745        deserializer.deserialize_struct("stream_plan.ValuesNode.ExprTuple", FIELDS, GeneratedVisitor)
15746    }
15747}
15748impl serde::Serialize for VectorIndexWriteNode {
15749    #[allow(deprecated)]
15750    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15751    where
15752        S: serde::Serializer,
15753    {
15754        use serde::ser::SerializeStruct;
15755        let mut len = 0;
15756        if self.table.is_some() {
15757            len += 1;
15758        }
15759        let mut struct_ser = serializer.serialize_struct("stream_plan.VectorIndexWriteNode", len)?;
15760        if let Some(v) = self.table.as_ref() {
15761            struct_ser.serialize_field("table", v)?;
15762        }
15763        struct_ser.end()
15764    }
15765}
15766impl<'de> serde::Deserialize<'de> for VectorIndexWriteNode {
15767    #[allow(deprecated)]
15768    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15769    where
15770        D: serde::Deserializer<'de>,
15771    {
15772        const FIELDS: &[&str] = &[
15773            "table",
15774        ];
15775
15776        #[allow(clippy::enum_variant_names)]
15777        enum GeneratedField {
15778            Table,
15779        }
15780        impl<'de> serde::Deserialize<'de> for GeneratedField {
15781            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15782            where
15783                D: serde::Deserializer<'de>,
15784            {
15785                struct GeneratedVisitor;
15786
15787                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15788                    type Value = GeneratedField;
15789
15790                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15791                        write!(formatter, "expected one of: {:?}", &FIELDS)
15792                    }
15793
15794                    #[allow(unused_variables)]
15795                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15796                    where
15797                        E: serde::de::Error,
15798                    {
15799                        match value {
15800                            "table" => Ok(GeneratedField::Table),
15801                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15802                        }
15803                    }
15804                }
15805                deserializer.deserialize_identifier(GeneratedVisitor)
15806            }
15807        }
15808        struct GeneratedVisitor;
15809        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15810            type Value = VectorIndexWriteNode;
15811
15812            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15813                formatter.write_str("struct stream_plan.VectorIndexWriteNode")
15814            }
15815
15816            fn visit_map<V>(self, mut map_: V) -> std::result::Result<VectorIndexWriteNode, V::Error>
15817                where
15818                    V: serde::de::MapAccess<'de>,
15819            {
15820                let mut table__ = None;
15821                while let Some(k) = map_.next_key()? {
15822                    match k {
15823                        GeneratedField::Table => {
15824                            if table__.is_some() {
15825                                return Err(serde::de::Error::duplicate_field("table"));
15826                            }
15827                            table__ = map_.next_value()?;
15828                        }
15829                    }
15830                }
15831                Ok(VectorIndexWriteNode {
15832                    table: table__,
15833                })
15834            }
15835        }
15836        deserializer.deserialize_struct("stream_plan.VectorIndexWriteNode", FIELDS, GeneratedVisitor)
15837    }
15838}
15839impl serde::Serialize for Watermark {
15840    #[allow(deprecated)]
15841    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15842    where
15843        S: serde::Serializer,
15844    {
15845        use serde::ser::SerializeStruct;
15846        let mut len = 0;
15847        if self.column.is_some() {
15848            len += 1;
15849        }
15850        if self.val.is_some() {
15851            len += 1;
15852        }
15853        let mut struct_ser = serializer.serialize_struct("stream_plan.Watermark", len)?;
15854        if let Some(v) = self.column.as_ref() {
15855            struct_ser.serialize_field("column", v)?;
15856        }
15857        if let Some(v) = self.val.as_ref() {
15858            struct_ser.serialize_field("val", v)?;
15859        }
15860        struct_ser.end()
15861    }
15862}
15863impl<'de> serde::Deserialize<'de> for Watermark {
15864    #[allow(deprecated)]
15865    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15866    where
15867        D: serde::Deserializer<'de>,
15868    {
15869        const FIELDS: &[&str] = &[
15870            "column",
15871            "val",
15872        ];
15873
15874        #[allow(clippy::enum_variant_names)]
15875        enum GeneratedField {
15876            Column,
15877            Val,
15878        }
15879        impl<'de> serde::Deserialize<'de> for GeneratedField {
15880            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15881            where
15882                D: serde::Deserializer<'de>,
15883            {
15884                struct GeneratedVisitor;
15885
15886                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15887                    type Value = GeneratedField;
15888
15889                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15890                        write!(formatter, "expected one of: {:?}", &FIELDS)
15891                    }
15892
15893                    #[allow(unused_variables)]
15894                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
15895                    where
15896                        E: serde::de::Error,
15897                    {
15898                        match value {
15899                            "column" => Ok(GeneratedField::Column),
15900                            "val" => Ok(GeneratedField::Val),
15901                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
15902                        }
15903                    }
15904                }
15905                deserializer.deserialize_identifier(GeneratedVisitor)
15906            }
15907        }
15908        struct GeneratedVisitor;
15909        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15910            type Value = Watermark;
15911
15912            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15913                formatter.write_str("struct stream_plan.Watermark")
15914            }
15915
15916            fn visit_map<V>(self, mut map_: V) -> std::result::Result<Watermark, V::Error>
15917                where
15918                    V: serde::de::MapAccess<'de>,
15919            {
15920                let mut column__ = None;
15921                let mut val__ = None;
15922                while let Some(k) = map_.next_key()? {
15923                    match k {
15924                        GeneratedField::Column => {
15925                            if column__.is_some() {
15926                                return Err(serde::de::Error::duplicate_field("column"));
15927                            }
15928                            column__ = map_.next_value()?;
15929                        }
15930                        GeneratedField::Val => {
15931                            if val__.is_some() {
15932                                return Err(serde::de::Error::duplicate_field("val"));
15933                            }
15934                            val__ = map_.next_value()?;
15935                        }
15936                    }
15937                }
15938                Ok(Watermark {
15939                    column: column__,
15940                    val: val__,
15941                })
15942            }
15943        }
15944        deserializer.deserialize_struct("stream_plan.Watermark", FIELDS, GeneratedVisitor)
15945    }
15946}
15947impl serde::Serialize for WatermarkFilterNode {
15948    #[allow(deprecated)]
15949    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
15950    where
15951        S: serde::Serializer,
15952    {
15953        use serde::ser::SerializeStruct;
15954        let mut len = 0;
15955        if !self.watermark_descs.is_empty() {
15956            len += 1;
15957        }
15958        if !self.tables.is_empty() {
15959            len += 1;
15960        }
15961        let mut struct_ser = serializer.serialize_struct("stream_plan.WatermarkFilterNode", len)?;
15962        if !self.watermark_descs.is_empty() {
15963            struct_ser.serialize_field("watermarkDescs", &self.watermark_descs)?;
15964        }
15965        if !self.tables.is_empty() {
15966            struct_ser.serialize_field("tables", &self.tables)?;
15967        }
15968        struct_ser.end()
15969    }
15970}
15971impl<'de> serde::Deserialize<'de> for WatermarkFilterNode {
15972    #[allow(deprecated)]
15973    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
15974    where
15975        D: serde::Deserializer<'de>,
15976    {
15977        const FIELDS: &[&str] = &[
15978            "watermark_descs",
15979            "watermarkDescs",
15980            "tables",
15981        ];
15982
15983        #[allow(clippy::enum_variant_names)]
15984        enum GeneratedField {
15985            WatermarkDescs,
15986            Tables,
15987        }
15988        impl<'de> serde::Deserialize<'de> for GeneratedField {
15989            fn deserialize<D>(deserializer: D) -> std::result::Result<GeneratedField, D::Error>
15990            where
15991                D: serde::Deserializer<'de>,
15992            {
15993                struct GeneratedVisitor;
15994
15995                impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
15996                    type Value = GeneratedField;
15997
15998                    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
15999                        write!(formatter, "expected one of: {:?}", &FIELDS)
16000                    }
16001
16002                    #[allow(unused_variables)]
16003                    fn visit_str<E>(self, value: &str) -> std::result::Result<GeneratedField, E>
16004                    where
16005                        E: serde::de::Error,
16006                    {
16007                        match value {
16008                            "watermarkDescs" | "watermark_descs" => Ok(GeneratedField::WatermarkDescs),
16009                            "tables" => Ok(GeneratedField::Tables),
16010                            _ => Err(serde::de::Error::unknown_field(value, FIELDS)),
16011                        }
16012                    }
16013                }
16014                deserializer.deserialize_identifier(GeneratedVisitor)
16015            }
16016        }
16017        struct GeneratedVisitor;
16018        impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
16019            type Value = WatermarkFilterNode;
16020
16021            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
16022                formatter.write_str("struct stream_plan.WatermarkFilterNode")
16023            }
16024
16025            fn visit_map<V>(self, mut map_: V) -> std::result::Result<WatermarkFilterNode, V::Error>
16026                where
16027                    V: serde::de::MapAccess<'de>,
16028            {
16029                let mut watermark_descs__ = None;
16030                let mut tables__ = None;
16031                while let Some(k) = map_.next_key()? {
16032                    match k {
16033                        GeneratedField::WatermarkDescs => {
16034                            if watermark_descs__.is_some() {
16035                                return Err(serde::de::Error::duplicate_field("watermarkDescs"));
16036                            }
16037                            watermark_descs__ = Some(map_.next_value()?);
16038                        }
16039                        GeneratedField::Tables => {
16040                            if tables__.is_some() {
16041                                return Err(serde::de::Error::duplicate_field("tables"));
16042                            }
16043                            tables__ = Some(map_.next_value()?);
16044                        }
16045                    }
16046                }
16047                Ok(WatermarkFilterNode {
16048                    watermark_descs: watermark_descs__.unwrap_or_default(),
16049                    tables: tables__.unwrap_or_default(),
16050                })
16051            }
16052        }
16053        deserializer.deserialize_struct("stream_plan.WatermarkFilterNode", FIELDS, GeneratedVisitor)
16054    }
16055}